public void AbreSolicitacaoRecursos(Calendario cal)
{
try
{
aulasBO.CriarAulas(cal);
alocacaoBO.preencheCalendario(cal);
configBO.setAulasDistribuidas(cal, true);
//instancia o usuario logado
MembershipUser user = Membership.GetUser();
//instancia o log
//LogEntry log = new LogEntry();
//monta log
//log.Message = "Calendário: " + cal.Ano + "/" + cal.Semestre +"; Administrador: " + user.UserName;
//log.TimeStamp = DateTime.Now;
//log.Severity = TraceEventType.Information;
//log.Title = "Abrir solicitação de Recursos";
//log.MachineName = Dns.GetHostName();
//guarda log no banco
//Logger.Write(log);
}
catch (IndexOutOfRangeException ex)
{
throw new DataAccessException("Não há categorias de atividades cadastradas no sistema.", ex);
}
catch (Exception ex)
{
throw new DataAccessException("Ocorreu um erro inesperado.", ex);
}
}
public void PreencheCalendarioDeAlocacoes(Calendario cal, Recurso rec, bool datasOrdenadas)
{
if (!datasOrdenadas)
{
cal.Datas.Sort();
}
DateTime data = cal.InicioG1;
Alocacao alocacao;
string[] listaHorarios = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "P" };
while (data != cal.FimG2)
{
if (data.DayOfWeek == DayOfWeek.Sunday)
{
foreach (string aux in listaHorarios)
{
alocacao = Alocacao.newAlocacao(rec, data, aux, null, null);
//try
//{
alocBO.InsereAlocacao(alocacao);
//}
//catch (Exception e)
//{
// throw e;
//}
}
data = data.AddDays(1);
}
data = data.AddDays(1);
}
}
public Transferencia GetTransferencia(Guid id, Calendario cal)
{
try
{
DbCommand cmd = baseDados.GetStoredProcCommand("TransferenciaSelectById");
baseDados.AddInParameter(cmd, "@Id", DbType.Guid, id);
Transferencia trans = null;
TurmaDAO turmaDAO = new TurmaDAO();
RecursosDAO recDAO = new RecursosDAO();
EventoDAO eventoDAO = new EventoDAO();
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
leitor.Read();
Guid transId = leitor.GetGuid(leitor.GetOrdinal("Id"));
Recurso rec = recDAO.GetRecurso(leitor.GetGuid(leitor.GetOrdinal("RecursoId")));
string hora = leitor.GetString(leitor.GetOrdinal("Horario"));
DateTime data = leitor.GetDateTime(leitor.GetOrdinal("Data"));
Turma turmaRecebeu = null;
Turma turmaTransferiu = null;
Evento eventoRecebeu = null;
Evento eventoTransferiu = null;
Guid? turmaRecId = leitor["TurmaRecebeu"] as Guid?;
if (turmaRecId.HasValue)
turmaRecebeu = turmaDAO.GetTurma(turmaRecId.Value, cal);
else turmaRecebeu = null;
Guid? turmaTransId = leitor["TurmaTransferiu"] as Guid?;
if (turmaTransId.HasValue)
turmaTransferiu = turmaDAO.GetTurma(turmaTransId.Value, cal);
else eventoTransferiu = null;
Guid? eventoRecId = leitor["EventoRecebeu"] as Guid?;
if (eventoRecId.HasValue)
eventoRecebeu = eventoDAO.GetEvento(eventoRecId.Value);
else eventoRecebeu = null;
Guid? eventoTransId = leitor["EventoTransferiu"] as Guid?;
if (eventoTransId.HasValue)
eventoTransferiu = eventoDAO.GetEvento(eventoTransId.Value);
else eventoTransferiu = null;
bool foiVisualizada = leitor.GetBoolean(leitor.GetOrdinal("FoiVisualizada"));
trans = new Transferencia(transId, rec, data, hora, turmaRecebeu, turmaTransferiu, foiVisualizada, eventoRecebeu, eventoTransferiu);
}
return trans;
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public Requisicao GetRequisicaoByAulaPrioridadeAndCategoria(Guid aulaId, Calendario cal, int prioridade, Guid catrecursoId)
{
try
{
return dao.GetRequisicaoByAulaPrioridadeAndCategoria(aulaId, cal, prioridade, catrecursoId);
}
catch (DataAccess.DataAccessException )
{
throw;
}
}
public List<Requisicao> GetRequisicoesPorAula(Guid? aulaId, Calendario cal)
{
try
{
return dao.GetRequisicoesPorAula(aulaId, cal);
}
catch (DataAccess.DataAccessException )
{
throw;
}
}
public List<Troca> GetTrocasAulasByProfessor(Guid profId, Calendario cal)
{
try
{
return dao.GetTrocasAulasByProfessor(profId, cal);
}
catch(DataAccessException)
{
throw;
}
}
public List<Transferencia> GetTransferencias(Guid profId, Calendario cal)
{
try
{
return dao.GetTransferencias(profId, cal);
}
catch (DataAccessException)
{
throw;
}
}
public Transferencia GetTransferencia(Guid id, Calendario cal)
{
try
{
return dao.GetTransferencia(id, cal);
}
catch (DataAccessException)
{
throw;
}
}
public List<Alocacao> GetAlocacoesByData(DateTime data, Calendario cal)
{
try
{
return dao.GetAlocacoesByData(data, cal);
}
catch (DataAccessException ex)
{
throw ex;
}
}
public Disciplina GetDisciplina(string cod,Calendario cal)
{
try
{
return dao.GetDisciplina(cod,cal);
}
catch (DataAccess.DataAccessException )
{
throw;
}
}
public List<Requisicao> GetRequisicaoByAulaAndPrioridade(Guid aulaId, Calendario cal, int prioridade)
{
try
{
return dao.GetRequisicaoByAulaAndPrioridade(aulaId, cal, prioridade);
}
catch (DataAccess.DataAccessException )
{
throw;
}
}
public Turma GetTurmaById(Guid id, Calendario cal)
{
try
{
return dao.GetTurma(id,cal);
}
catch (DataAccessException )
{
throw;
}
}
public bool IsAulasDistribuidas(Calendario calId)
{
DbCommand cmd = baseDados.GetStoredProcCommand("ConfigSelectAulasDistribuidas");
baseDados.AddInParameter(cmd, "@CalId", DbType.Guid, calId.Id);
try
{
bool i = Convert.ToBoolean(baseDados.ExecuteScalar(cmd));
return i;
}
catch (Exception ex)
{
throw new DataAccessException("Erro ao ler dados", ex);
}
}
/// <summary>
/// Cancela o mapeamento de um professor para um semestre
/// </summary>
/// <param name="prof">Professor</param>
/// <param name="cal">Calendario</param>
public void CancelaProfessor(Professor prof, Calendario cal)
{
DbCommand cmd = baseDados.GetStoredProcCommand("ProfessoresCalendarioDelete");
baseDados.AddInParameter(cmd, "@UserId", DbType.Guid, prof.Id);
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, cal.Id);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public AppState GetAppState(Calendario calId)
{
DbCommand cmd = baseDados.GetStoredProcCommand("ConfigSelectEstadoAtual");
baseDados.AddInParameter(cmd, "@CalId", DbType.Guid, calId.Id);
try
{
int i = Convert.ToInt32(baseDados.ExecuteScalar(cmd));
return (AppState)i;
}
catch (Exception ex)
{
throw new DataAccessException("Erro ao ler dados", ex);
}
}
/// <summary>
/// Cancela o mapeamento da disciplina para o semestre espeficicado
/// </summary>
/// <param name="disc">Disciplina</param>
/// <param name="cal">Calendario</param>
public void CancelaDisciplina(Disciplina disc, Calendario cal)
{
DbCommand cmd = baseDados.GetStoredProcCommand("DisciplinasInCalendarioDelete");
baseDados.AddInParameter(cmd, "@DisciplinaCod", DbType.String, disc.Cod);
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, cal.Id);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public void createConfig(Calendario calId)
{
DbCommand cmd = baseDados.GetStoredProcCommand("ConfigCreateConfig");
baseDados.AddInParameter(cmd, "@CalId", DbType.Guid, calId.Id);
baseDados.AddInParameter(cmd, "@Estado", DbType.Int32, 0);
baseDados.AddInParameter(cmd, "@AulasDistribuidas", DbType.Boolean, false);
baseDados.AddInParameter(cmd, "@RecursosDistribuidos", DbType.Boolean, false);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (Exception ex)
{
throw new DataAccessException("Erro ao ler dados", ex);
}
}
public Disciplina GetDisciplina(string cod, Calendario cal, List<BusinessData.Entities.CategoriaDisciplina> categoriasDeDisciplina)
{
DbCommand cmd = baseDados.GetStoredProcCommand("DisciplinaSelectByCod");
baseDados.AddInParameter(cmd, "@DisciplinaCod", DbType.String, cod);
Entities.Disciplina aux = null;
Entities.CategoriaDisciplina categoria = null;
try
{
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
leitor.Read();
Guid categId = leitor.GetGuid(leitor.GetOrdinal("Categoria"));
foreach(CategoriaDisciplina categDisc in categoriasDeDisciplina)
{
if(categDisc.Id.Equals(categId))
{
categoria = categDisc;
}
}
if(categoria == null)
{
throw new Exception("Categoria de disciplina não encontrada");
}
aux = Entities.Disciplina.GetDisciplina(leitor.GetString(leitor.GetOrdinal("DisciplinaCod")),
leitor.GetInt32(leitor.GetOrdinal("Cred")),
leitor.GetString(leitor.GetOrdinal("Nome")),
leitor.GetBoolean(leitor.GetOrdinal("G2")),
cal,
categoria
);
}
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
return aux;
}
protected string GrabarComo(string sIDcal, string sDesCal, string sCodUne, string sEstado, string sTipo, string sObs, string sIdFicepiResp, string sCodProvincia)
{
string sResul = "";
int? iCodProvincia = null;
if (sCodProvincia != "")
{
iCodProvincia = int.Parse(sCodProvincia);
}
int?idFicepiResponsable = null;
if (sIdFicepiResp != "")
{
idFicepiResponsable = int.Parse(sIdFicepiResp);
}
try
{
int nResul = Calendario.Insertar(Utilidades.unescape(sDesCal), int.Parse(sCodUne), int.Parse(sEstado), sTipo,
int.Parse(Session["IDFICEPI_PC_ACTUAL"].ToString()), sObs, idFicepiResponsable, iCodProvincia);
//this.hdnIDCalendario.Text = sIDcalNew.ToString();
Session["IDCalendario"] = nResul;
Calendario.InsertarHorasComo(int.Parse(sIDcal), nResul);
sResul = "OK@#@" + nResul.ToString();
}
catch (Exception ex)
{
if (ex.Message.Contains("IX_T039_CALENDARIO_1"))
{
sResul = "Error@#@" + Errores.mostrarError("No puede existir una denominación de calendario repetida dentro del mismo C.R.");
}
else
{
sResul = "Error@#@" + Errores.mostrarError("Error al grabar el detalle del calendario", ex);
}
}
return(sResul);
}
public List <Disciplina> GetDisciplinas()
{
DbCommand cmd = baseDados.GetStoredProcCommand("DisciplinaSelectAll");
Disciplina aux;
List <Disciplina> listaAux = new List <Disciplina>();
try
{
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
CalendariosDAO calendariosDAO = new CalendariosDAO();
CategoriaDisciplinaDAO catdiscipDAO = new CategoriaDisciplinaDAO();
Calendario calendario = null;
CategoriaDisciplina categoria = null;
while (leitor.Read())
{
calendario = null;
categoria = catdiscipDAO.GetCategoriaDisciplina(leitor.GetGuid(leitor.GetOrdinal("Categoria")));
aux = Entities.Disciplina.GetDisciplina(leitor.GetString(leitor.GetOrdinal("DisciplinaCod")),
leitor.GetInt32(leitor.GetOrdinal("Cred")),
leitor.GetString(leitor.GetOrdinal("Nome")),
leitor.GetBoolean(leitor.GetOrdinal("G2")),
calendario,
categoria
);
listaAux.Add(aux);
}
}
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
return(listaAux);
}
public void Test_eFi_Crono35()
{
const string RESTRICAO = "CalendarioConflitante";
Calendario calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest, CsCalendarioDomain.Folga,
new DateTime(2010, 11, 15), new DateTime(2010, 11, 20));
calendario.CsSituacao = CsSituacaoDomain.Inativo;
calendario.Save();
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Folga, new DateTime(2010, 11, 15), new DateTime(2010, 11, 16));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 20), new DateTime(2010, 11, 25));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 16), new DateTime(2010, 11, 19));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 14), new DateTime(2010, 11, 21));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 15), new DateTime(2010, 11, 20));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
}
internal async static Task InserisciPrenotazione(string IDesercente, string IDCalendario, string IDUtente, string Nota)
{
var vRealmDb = await GetRealm();
Esercente esercente = vRealmDb.Find <Esercente>(IDesercente);
Calendario calendario = vRealmDb.Find <Calendario>(IDCalendario);
Utente utente = vRealmDb.Find <Utente>(IDUtente);
var trans = vRealmDb.BeginWrite();
Prenotazione md = new Prenotazione
{
Esercente = esercente,
Calendario = calendario,
Utente = utente,
Nota = Nota
};
vRealmDb.Add(md);
trans.Commit();
}
private List <GestionRentabilidadSeguimiento> GetList()
{
try
{
Sesion sesion = (Sesion)Session["Sesion" + Session.SessionID];
CN_CatCalendario cn_calenda = new CN_CatCalendario();
Calendario c = new Calendario();
Sesion Sesion = new Sesion();
Sesion = (Sesion)Session["Sesion" + Session.SessionID];
cn_calenda.ConsultaCalendarioActual(ref c, Sesion);
List <GestionRentabilidadSeguimiento> listGestionRentabilidadSeguimiento = new List <GestionRentabilidadSeguimiento>();
GestionRentabilidadSeguimiento gestionRentabilidadseguimiento = new GestionRentabilidadSeguimiento();
new CN_GestionRentabilidadSeguimiento().ConsultaGestionRentabilidadSeguimiento_Buscar(gestionRentabilidadseguimiento
, sesion.Emp_Cnx
, ref listGestionRentabilidadSeguimiento
, sesion.Id_Emp
, sesion.Id_Cd_Ver
, this.txtTerritorio.Text == string.Empty ? 0 : Convert.ToInt32(this.txtTerritorio.Text)
, this.TxtNumeroCliente.Text == string.Empty ? 0 : Convert.ToInt32(this.TxtNumeroCliente.Text)
);
return(listGestionRentabilidadSeguimiento);
}
catch (Exception ex)
{
throw ex;
}
}
private string ObtenerCalendarios(string sTipo, string sIdFicepi, string sNodo)
{
try
{
StringBuilder sb = new StringBuilder();
SqlDataReader dr = null;
sb.Append("<table id='tblDatos' class='texto MA' style='width: 400px;'>");
sb.Append("<colgroup><col style='width: 400px;' /></colgroup>");
sb.Append("<tbody>");
if (sTipo == "E")
{
dr = Calendario.Catalogo(null, "", true, "E", null, "", null, 2, 0);
}
else
{
if (sNodo == "")
{
sNodo = "-1";
}
dr = Calendario.Asignacion(int.Parse(sNodo), int.Parse(sIdFicepi));
}
while (dr.Read())
{
sb.Append("<tr id='" + dr["t066_idcal"].ToString() + "' onclick='ms(this)' ondblclick='aceptarClick(this.rowIndex)' onmouseover='TTip(event);' style='height:16px'>");
sb.Append("<td style='padding-left:5px;'><nobr style='width:380px;' class='NBR'>" + dr["t066_descal"].ToString() + "</nobr></td></tr>");
}
dr.Close();
dr.Dispose();
sb.Append("</tbody>");
sb.Append("</table>");
return("OK@#@" + sb.ToString());
}
catch (Exception ex)
{
return("Error@#@" + Errores.mostrarError("Error al obtener los Calendarios", ex));
}
}
/// <summary>
/// Retorna um calendário de acordo com ano/semestre
/// throws BusinessData.BusinessLogic.DataAccess.DataAccessExceptiom
/// </summary>
/// <returns>Calendario</returns>
public Calendario GetCalendarioByAnoSemestre(int ano, int semestre)
{
DbCommand cmd = baseDados.GetStoredProcCommand("CalendarioSelectByAnoAndSemestre");
baseDados.AddInParameter(cmd, "@Ano", DbType.Int32, ano);
baseDados.AddInParameter(cmd, "@Semestre", DbType.Int32, semestre);
Entities.Calendario aux = null;
try
{
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
leitor.Read();
DatasDAO datasDao = new DatasDAO();
List <Entities.Data> datas;
try
{
datas = datasDao.GetDatasByCalendario(leitor.GetGuid(leitor.GetOrdinal("CalendarioId")));
aux = Calendario.GetCalendario(leitor.GetGuid(leitor.GetOrdinal("CalendarioId")),
semestre, ano, datas,
leitor.GetDateTime(leitor.GetOrdinal("InicioG1")),
leitor.GetDateTime(leitor.GetOrdinal("InicioG2")),
leitor.GetDateTime(leitor.GetOrdinal("FimG2")));
}
catch (InvalidOperationException)
{
return(null);
}
}
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
return(aux);
}
private void bt_calendario_Click(object sender, EventArgs e)
{
panel_selected_window.Height = bt_calendario.Height;
panel_selected_window.Top = bt_calendario.Top;
Calendario calendar2 = new Calendario();
calendar2.Dock = DockStyle.Fill;
if (calendar != null)
{
calendar.Dispose(); //no overload the memory
}
calendar = calendar2;
//Cerrar todo
profile.Visible = false;
help.Visible = false;
cb.Visible = false;
profile.Dispose();
//Mostrar nuevo form
calendar.Visible = true;
panel_principal.Controls.Add(calendar);
}
protected void VerificaTransferencias()
{
Calendario cal = (Calendario)Session["Calendario"];
MembershipUser user = Membership.GetUser();
Guid professorId = new Guid(user.ProviderUserKey.ToString());
List <Transferencia> trans = transBO.GetTransferencias(professorId, cal);
Session["Transferencias"] = trans;
if (trans.Count != 0)
{
dgTransferencias.DataSource = trans;
dgTransferencias.DataBind();
dgTransferencias.Visible = true;
lblTransfencia.Visible = true;
}
else
{
dgTransferencias.Visible = false;
lblTransfencia.Visible = false;
}
}
public static void IngresarFechaVuelta(string fecha)
{
Boolean bandera = false;
Driver.FindElement(PantallaDeInicio.InputFechaVuelta).Click();
List <IWebElement> CalendarioFechaPartida = Driver.FindElement(PantallaDeInicio.CalendarioRegreso).FindElements(By.TagName("td")).ToList();
foreach (IWebElement Calendario in CalendarioFechaPartida)
{
if (fecha.Equals(Calendario.Text))
{
Calendario.Click();
bandera = true;
break;
}
}
if (!bandera)
{
Console.WriteLine("[LOG] LA FECHA INGRESADA NO EXISTE");
}
}
public HttpResponseMessage Get([FromUri] int Id, [FromUri] string cultura, [FromUri] string[] include, [FromUri] bool indent = false)
{
try {
var formatter = new MaxDepthJsonMediaTypeFormatter()
{
Indent = indent
};
if (include.Length > 0)
{
formatter.SerializerSettings.MaxDepth = 100; //include.Max<string>(s => s.Split('.').Length * 5);
formatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
}
else
{
formatter.SerializerSettings.MaxDepth = 1;
}
Calendario _calendario = calendarioRepository.GetById(include, (p => p.Id == Id));
if (cultura != Localizacion.CulturaPorDefecto)
{
Calendario_Idioma _calendarioIdioma = calendario_IdiomaRepository.GetMany(p => p.IdRegistro == Id && p.Cultura == cultura).FirstOrDefault();
// Campos multiidioma
if (_calendarioIdioma != null)
{
_calendario.Nombre = _calendarioIdioma.Nombre;
_calendario.Variante = _calendarioIdioma.Variante;
}
}
if (_calendario == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(Request.CreateResponse <Calendario>(HttpStatusCode.OK, _calendario, formatter));
} catch (Exception _excepcion) {
log.Error(_excepcion);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, _excepcion));
}
}
public void InsereRecurso(Recurso recurso, Calendario cal)
{
if (usr.IsAdmin())
{
ConfigBO configuracoes = new ConfigBO();
try
{
dao.InsereRecurso(recurso);
//instancia o usuario logado
//MembershipUser user = Membership.GetUser();
//instancia o log
//LogEntry log = new LogEntry();
//monta log
//log.Message = "Recurso: " + recurso.Descricao + "; Id: " + recurso.Id + "; Administrador: " + user.UserName;
//log.TimeStamp = DateTime.Now;
//log.Severity = TraceEventType.Information;
//log.Title = "Insert Recurso";
//log.MachineName = Dns.GetHostName();
//guarda log no banco
//Logger.Write(log);
if (configuracoes.IsAulasDistribuidas(cal))
{
AlocacaoBO aloc = new AlocacaoBO();
aloc.PreencheCalendarioDeAlocacoes(cal, recurso, false);
}
}
catch (DataAccessException)
{
throw;
}
}
else
{
throw new SecurityException("Acesso Negado.");
}
}
protected void btnConfirmar_Click(object sender, EventArgs e)
{
try
{
Calendario cal = (Calendario)Session["Calendario"];
Recurso recurso;
listaHorarios = (List <HorarioBloqueado>)Session["Horarios"];
CategoriaRecurso categoriaRecurso = categBO.GetCategoriaRecursoById(new Guid(ddlCategoria.SelectedValue));
Faculdade vinculo = faculBO.GetFaculdadeById(new Guid(ddlVinculo.SelectedValue));
if (listaHorarios.Count != 0)
{
recurso = Recurso.NewRecurso(txtDescricao.Text, txtAbrev.Text, txtTipo.Text[0], vinculo, categoriaRecurso, Convert.ToBoolean(Convert.ToInt16(rblDisponivel.SelectedValue)), listaHorarios);
}
else
{
recurso = Recurso.NewRecurso(txtDescricao.Text, txtAbrev.Text, txtTipo.Text[0], vinculo, categoriaRecurso, Convert.ToBoolean(Convert.ToInt16(rblDisponivel.SelectedValue)), null);
}
recursoBO.InsereRecurso(recurso, cal);
txtDescricao.Text = "";
ddlHorarioInicio.SelectedIndex = 0;
ddlHorarioFim.SelectedIndex = 0;
dgHorarios.DataSource = null;
dgHorarios.DataBind();
pnlHorarios.Visible = false;
listaHorarios.Clear();
Session["Horarios"] = listaHorarios;
lblStatus.Text = "Recurso cadastrado com sucesso.";
lblStatus.Visible = true;
}
catch (BusinessData.DataAccess.DataAccessException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
/// <summary>
/// Método auxiliar para cadastrar datas no calendário do wex
/// </summary>
/// <param name="descricao">descrição da data cadastrada</param>
/// <param name="tipoCalendario">tipo de data (Folga ou Trabalho)</param>
/// <param name="tipoVigencia">tipo de vigência da data do calendário</param>
/// <param name="dataInicio">data de inicio</param>
/// <param name="dataTermino">data de término do período (Opcional, usado apenas quando a vigência for por período)</param>
private void AdicionarCalendario(string descricao, CsCalendarioDomain tipoCalendario, CsVigenciaDomain tipoVigencia, DateTime dataInicio, DateTime?dataTermino = null)
{
//TODO: REVER SE DEVERÁ SER PASSADO PARA O CalendarioBo
Calendario calendario = new Calendario()
{
CsCalendario = tipoCalendario.ToInt(),
CsVigencia = tipoVigencia.ToInt(),
DtInicio = dataInicio.Date,
Periodo = dataInicio.Date,
Oid = Guid.NewGuid(),
TxDescricao = descricao,
CsSituacao = CsSituacaoDomain.Ativo.ToInt()
};
switch (tipoVigencia)
{
case CsVigenciaDomain.PorDiaMes:
calendario.CsMes = dataInicio.Month;
calendario.NbDia = dataInicio.Day;
break;
case CsVigenciaDomain.PorDiaMesAno:
break;
case CsVigenciaDomain.PorPeriodo:
if (!dataTermino.HasValue)
{
throw new ArgumentException("Deveria ter preenchido a data de término do período.");
}
calendario.DtTermino = dataTermino.Value.Date;
break;
default:
break;
}
contexto.Calendarios.Add(calendario);
contexto.SaveChanges();
}
protected void VerificaTrocas()
{
List <Troca> trocasAulas = new List <Troca>();
List <Troca> trocasEventos = new List <Troca>();
Calendario cal = (Calendario)Session["Calendario"];
MembershipUser user = Membership.GetUser();
Guid professorId = new Guid(user.ProviderUserKey.ToString());
try
{
trocasAulas = trocaBO.GetTrocasAulasByProfessor(professorId, cal);
trocasEventos = trocaBO.GetTrocasEventosByAutor(professorId, cal);
}
catch (Exception ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
foreach (Troca t in trocasEventos)
{
trocasAulas.Add(t);
}
Session["Trocas"] = trocasAulas;
if (trocasAulas.Count != 0)
{
dgTroca.DataSource = trocasAulas;
dgTroca.DataBind();
lblRotulo.Visible = true;
dgTroca.Visible = true;
}
else
{
lblRotulo.Visible = false;
dgTroca.Visible = false;
}
}
internal ERespuestaCalendario OpeActualizar(Calendario calendario)
{
ERespuestaCalendario eRespuesta = new ERespuestaCalendario();
using (var cal = new cita_doctorContext())
{
var theCalendar = (from cl in cal.Calendario
.Where(c => (c.Id == calendario.Id))
select cl).FirstOrDefault();
theCalendar.IdDoctor = calendario.IdDoctor;
theCalendar.IdEstado = calendario.IdEstado;
theCalendar.Sintomas = calendario.Sintomas;
theCalendar.Diagnostico = calendario.Diagnostico;
theCalendar.Indicaciones = calendario.Indicaciones;
theCalendar.IdDoctor = calendario.IdDoctor;
theCalendar.IdEstado = calendario.IdEstado;
try
{
cal.SaveChanges();
eRespuesta.Calendarios.Add(_mapper.Map <EOutCalendario>(calendario));
eRespuesta.Error.Codigo = "00";
eRespuesta.Error.Mensaje = "Ok";
}
catch (Exception e)
{
eRespuesta.Error.Codigo = "01";
eRespuesta.Error.Mensaje = e.Message;
return(eRespuesta);
}
}
eRespuesta.Calendarios.Add(_mapper.Map <EOutCalendario>(calendario));
return(eRespuesta);
}
private void Chatbot_menu_Load(object sender, EventArgs e)
{
loadUserdata();
//Create objects
_loggedUser = new ModeloUsuario();
//Create Ayuda
help = new Ayuda();
//User control create
_obj = this;
cb = new Chatbot();
cb.Dock = DockStyle.Fill;
panel_principal.Controls.Add(cb);
//Instanciacion inicial
profile = new Perfil_usuario();
calendar = new Calendario();
help.Visible = false;
profile.Visible = false;
calendar.Visible = false;
}
public ActionResult Delete(int id)
{
Calendario model = DataBase.Calendarios.Get(p => p.IdCalendario == id, includeProperties: "DiasNoLaborables, DiasLaborales").FirstOrDefault();
InicializarTab();
foreach (DiaLaboral lab in model.DiasLaborales)
{
lab.DiaString = DataBase.GeneralValues.Get(p => p.Code == lab.IdDia && p.Id == Rp3.AgendaComercial.Models.Constantes.DiasSemana.Tabla).Select(p => p.Content).FirstOrDefault();
if (lab.EsLaboral)
{
lab.HoraInicio1 = lab.HoraInicio1.Replace("h", ":");
lab.HoraFin1 = lab.HoraFin1.Replace("h", ":");
if (lab.HoraInicio2 != null && lab.HoraInicio2 != "")
{
lab.HoraInicio2 = lab.HoraInicio2.Replace("h", ":");
lab.HoraFin2 = lab.HoraFin2.Replace("h", ":");
lab.SegundaJornada = true;
}
}
}
ViewBag.ReadOnly = true;
return(View(model));
}
public ActionResult Create()
{
Calendario model = new Calendario();
model.DiasLaborales = new List <DiaLaboral>();
model.DiasNoLaborables = new List <DiasNoLaborable>();
for (int i = 1; i <= 7; i++)
{
model.DiasLaborales.Add(new DiaLaboral()
{
IdDia = i + "",
DiaString = DataBase.GeneralValues.Get(p => p.Code == i + "" && p.Id == Rp3.AgendaComercial.Models.Constantes.DiasSemana.Tabla).Select(p => p.Content).FirstOrDefault(),
IdDiaTabla = Rp3.AgendaComercial.Models.Constantes.DiasSemana.Tabla,
EsLaboral = i < 6 ? true : false,
SegundaJornada = i < 6 ? true : false
});
}
InicializarTab();
ViewBag.ReadOnly = false;
return(View(model));
}
public async Task <IActionResult> Create([Bind("CalendarioId,Ano,Semestre,DataInicio,DataFim,Ativo")] Calendario calendario)
{
if (ModelState.IsValid)
{
if (_context.Calendario.Where(x => x.Ano == calendario.Ano && x.Semestre == calendario.Semestre).ToList().Count > 0)
{
TempData["Error"] = "Operação cancelada! Já existe um Calendário de banca cadastrado para o ano " + calendario.Ano + "." + calendario.Semestre;
return(View(calendario));
}
else if (calendario.Ativo && _context.Calendario.Where(x => x.Ativo == true).ToList().Count > 0)
{
TempData["Error"] = "Operação cancelada! Não é possível ter mais de um calendário de banca ativo simultaneamente.";
return(View(calendario));
}
_context.Add(calendario);
await _context.SaveChangesAsync();
TempData["Success"] = "Calendário de banca cadastrado com sucesso.";
return(RedirectToAction(nameof(Index)));
}
return(View(calendario));
}
public ActionResult Delete(int id)
{
try
{
if (!_tokenManager.GenerateToken())
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
_ICalendarioApiConsumer.SetAuthHeader(_tokenManager.Token);
Calendario varCalendario = null;
if (id.ToString() != "0")
{
string where = "";
}
var result = _ICalendarioApiConsumer.Delete(id, null, null).Resource;
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (ServiceException ex)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
protected void PopulaListaDisciplinas()
{
try
{
Calendario cal = (Calendario)Session["Calendario"];
List <Disciplina> listaDisciplinas = disciBo.GetDisciplinas(cal.Id);
if (listaDisciplinas.Count == 0)
{
lblStatus.Text = "Nenhuma disciplina cadastrada.";
lblStatus.Visible = true;
}
else
{
grvListaDisciplinas.DataSource = listaDisciplinas;
grvListaDisciplinas.DataBind();
}
}
catch (BusinessData.DataAccess.DataAccessException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
//GET
public ActionResult Jogo(int?id)
{
try
{
Jogo jogo;
List <Adversario> adversarios = AdversarioBll.RetornarAdversariosAtivos().ToList();
List <Calendario> calendarios = CalendarioBll.ListarCalendarios().ToList();
List <LocalJogo> locaisJogo = LocalJogoBll.RetornarLocaisJogoAtivos().ToList();
ViewBag.Adversarios = adversarios;
ViewBag.Calendarios = calendarios;
ViewBag.LocaisJogo = locaisJogo;
if (id == null)
{
jogo = new Jogo();
if (calendarios.Count > 0)
{
Calendario calendario = calendarios.Where(c => c.Ano == DateTime.Now.Year).FirstOrDefault();
jogo.CalendarioID = calendario.ID;
}
}
else
{
jogo = JogoBll.RetornarJogo(id);
}
return(View(jogo));
}
catch (Exception exception)
{
LogBll.GravarErro(exception, User.Identity.Name);
return(RedirectToAction("Index").ComMensagem(Resources.Geral.ContateAdministrador, TipoMensagem.Erro));
}
}
public static List <Feriado> ObterListaDeFeriados(int ano)
{
var ListaDeFeriados = new List <Feriado>();
ListaDeFeriados.Add(Calendario.ObterFeriadoAjustadoParaFinalDeSemana(ano, Feriados.NewYearsDay));
if (ano >= 1983)
{
ListaDeFeriados.Add(new Feriado(Calendario.ObterDia(ano, 1, DayOfWeek.Monday, 3), Feriados.MartinLutherKingsBirthday.Mes, Feriados.MartinLutherKingsBirthday.Descricao));
}
ListaDeFeriados.Add(new Feriado(Calendario.ObterUltimoDia(ano, 5, DayOfWeek.Monday), Feriados.MemorialDay.Mes, Feriados.MemorialDay.Descricao));
ListaDeFeriados.Add(Calendario.ObterFeriadoAjustadoParaFinalDeSemana(ano, Feriados.IndependenceDay));
ListaDeFeriados.Add(new Feriado(Calendario.ObterDia(ano, 9, DayOfWeek.Monday, 1), Feriados.LaborDay.Mes, Feriados.LaborDay.Descricao));
if (ano >= 1971)
{
ListaDeFeriados.Add(new Feriado(Calendario.ObterDia(ano, 10, DayOfWeek.Monday, 2), Feriados.ColumbusDay.Mes, Feriados.ColumbusDay.Descricao));
}
if (ano <= 1970 || ano >= 1978)
{
ListaDeFeriados.Add(Calendario.ObterFeriadoAjustadoParaFinalDeSemana(ano, Feriados.VeteransDay));
}
else
{
ListaDeFeriados.Add(new Feriado(Calendario.ObterDia(ano, 10, DayOfWeek.Monday, 4), Feriados.VeteransDay.Mes, Feriados.VeteransDay.Descricao));
}
ListaDeFeriados.Add(new Feriado(Calendario.ObterDia(ano, 11, DayOfWeek.Thursday, 4), Feriados.ThanksgivingDay.Mes, Feriados.ThanksgivingDay.Descricao));
ListaDeFeriados.Add(Calendario.ObterFeriadoAjustadoParaFinalDeSemana(ano, Feriados.Christmas));
return(ListaDeFeriados);
}
public async Task <IActionResult> Create([Bind("CalendarioId,Ano,Semestre,DataInicio,DataFim,Ativo")] Calendario calendario)
{
if (ModelState.IsValid)
{
if (_context.Calendario.Where(x => x.Ano == calendario.Ano && x.Semestre == calendario.Semestre).ToList().Count > 0)
{
TempData["Error"] = "Operação cancelada! Já existe um Calendário de banca cadastrado para o ano " + calendario.Ano + "." + calendario.Semestre;
return(View(calendario));
}
else if (calendario.Ativo && _context.Calendario.Where(x => x.Ativo == true).ToList().Count > 0)
{
TempData["Error"] = "Operação cancelada! Não é possível ter mais de um calendário de banca ativo simultaneamente.";
return(View(calendario));
}
_context.LogAuditoria.Add(
new LogAuditoria
{
EmailUsuario = User.Identity.Name,
Ip = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
Date = DateTime.Now.ToLongDateString(),
DetalhesAuditoria = "Cadastrou um calendario",
IdItem = calendario.CalendarioId.ToString()
});
_context.Add(calendario);
await _context.SaveChangesAsync();
TempData["Success"] = "Calendário de banca cadastrado com sucesso.";
return(RedirectToAction(nameof(Index)));
_context.SaveChanges();
}
return(View(calendario));
}
public List <Calendario> devolverTodosCalendario(DateTime fechaDesde, DateTime fechaHasta, int idEspacio)
{
try
{
List <Calendario> listaCalendario = new List <Calendario>();
using (var db = new ModeloRenacer())
{
List <DetalleEvento> listaDetalle = db.detalleEvento.
Include("espacio").
Include("responsable")
.Where(ev => ev.fechaDesde >= fechaDesde && ev.fechaDesde <= fechaHasta && ev.fechaBaja == null)
.Where(ev => ev.idEspacio == idEspacio || idEspacio == 0)
.ToList();
foreach (var item in listaDetalle)
{
Calendario itemCalendario = new Calendario();
itemCalendario.id = item.id;
itemCalendario.nombre = item.nombre;
itemCalendario.descripcion = item.descripcion;
itemCalendario.idEvento = item.idEvento;
itemCalendario.dia = item.dia;
itemCalendario.fechaDesde = item.fechaDesde;
itemCalendario.fechaHasta = item.fechaHasta;
itemCalendario.aula = item.espacio.nombre;
itemCalendario.encargado = item.responsable.nombre + " " + item.responsable.apellido;
listaCalendario.Add(itemCalendario);
}
return(listaCalendario);
}
}
catch (Exception ex)
{
ServicioSentry.devolverSentry().informarExcepcion(ex);
}
return(null);
}
public List <Evento> GetEventosByCal(Guid id)
{
List <Evento> listaAux;
try
{
DbCommand cmd = baseDados.GetStoredProcCommand("EventoSelectByCal");
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, id);
listaAux = new List <BusinessData.Entities.Evento>();
Evento aux;
CalendariosDAO calendarios = new CalendariosDAO();
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
while (leitor.Read())
{
PessoaBase autor = null;
autor = PessoaFactory.GetInstance().CreatePessoa(leitor.GetGuid(leitor.GetOrdinal("AutorId")));
Calendario calendario = calendarios.GetCalendario(leitor.GetGuid(leitor.GetOrdinal("CalendarioId")));
aux = Evento.GetEvento(leitor.GetGuid(leitor.GetOrdinal("EventoId")),
autor,
leitor.GetString(leitor.GetOrdinal("Descricao")),
calendario,
leitor.GetString(leitor.GetOrdinal("Responsavel")),
leitor.GetString(leitor.GetOrdinal("Titulo")),
leitor.GetString(leitor.GetOrdinal("Unidade")));
listaAux.Add(aux);
}
}
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
return(listaAux);
}
private Calendario CriarCalendario(string descricao, CsCalendarioDomain tipoCalendario, CsVigenciaDomain tipoVigencia, DateTime dataInicio, CsSituacaoDomain situacao, DateTime?dataTermino = null)
{
Calendario calendario = new Calendario()
{
CsCalendario = tipoCalendario.ToInt(),
CsVigencia = tipoVigencia.ToInt(),
DtInicio = dataInicio.Date,
Periodo = dataInicio.Date,
Oid = Guid.NewGuid(),
TxDescricao = descricao,
CsSituacao = situacao.ToInt()
};
switch (tipoVigencia)
{
case CsVigenciaDomain.PorDiaMes:
calendario.CsMes = dataInicio.Month;
calendario.NbDia = dataInicio.Day;
break;
case CsVigenciaDomain.PorDiaMesAno:
break;
case CsVigenciaDomain.PorPeriodo:
if (!dataTermino.HasValue)
{
throw new ArgumentException("Deveria ter preenchido a data de término do período.");
}
calendario.DtTermino = dataTermino.Value.Date;
break;
default:
break;
}
return(calendario);
}
protected void grvListaTurmas_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
try
{
TurmaBO turma = new TurmaBO();
Calendario cal = (Calendario)Session["Calendario"];
Guid id = (Guid)grvListaTurmas.DataKeys[e.RowIndex].Value;
turma.DeletaTurma(id);
lblStatus.Text = "Turma excluída com sucesso.";
lblStatus.Visible = true;
grvListaTurmas.DataSource = turma.GetTurmas(cal);
grvListaTurmas.DataBind();
}
catch (BusinessData.DataAccess.DataAccessException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
catch (SecurityException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
protected void wzImportarTurmas_FinishButtonClick(object sender, WizardNavigationEventArgs e)
{
try
{
SPABO sistAcademico = new SPABO();
//listaTurmas = (IList<Turma>)Session["listaTurmas"];
//Calendario calId = (Calendario)(Session["Calendario"]);
// Ugly fix
CalendariosBO cadastroCalendarios = new CalendariosBO();
List <Calendario> listaCalendarios = cadastroCalendarios.GetCalendarios();
listaCalendarios.Sort();
Session["Calendario"] = listaCalendarios[0];
Calendario calId = (Calendario)(Session["Calendario"]);
listaTurmas = sistAcademico.getTurmas(calId.Id);
sistAcademico.ImportaTurmas(listaTurmas);
lblSucesso.Text = "Turmas importadas com sucesso!";
}
catch (Exception ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
Session["Opcoes"] = 0;
if (Session["Calendario"] == null)
{
Response.Redirect("../Default/SelecionarCalendario.aspx");
}
listaRequisicoes = new List<DecoratorRequisicoes>();
if (Request.QueryString["AulaId"] != String.Empty)
{
try
{
AulaBO controleAulas = new AulaBO();
aulaAtual = controleAulas.GetAulaById(new Guid(Request.QueryString["AulaId"]));
Session.Add("aulaAtual", aulaAtual);
}
catch (Exception )
{
Response.Redirect("../Docentes/SelecionaTurma.aspx");
}
}
PopulaDDLCategoriaRecursos();
GetRequisicoes();
listaRequisicoes = Session["listaRequisicoes"] as List<DecoratorRequisicoes>;
Session["Opcoes"] = listaRequisicoes.Count;
}
calendarioAtual = (Calendario)Session["Calendario"];
listaRequisicoes = Session["listaRequisicoes"] as List<DecoratorRequisicoes>;
aulaAtual = Session["aulaAtual"] as Aula;
limparSessao = false;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
aulaBo = new AulaBO();
reqBo = new RequisicoesBO();
try
{
cal = (Calendario)Session["Calendario"];
// Obtém as requisições do semestre (todas)
IList<Requisicao> listaReq = reqBo.GetRequisicoesPorCalendario(cal);
// Cria um conjunto para armazenar os números das turmas com pedidos de recursos
reqTurmas = new HashSet<Guid>();
foreach (Requisicao req in listaReq)
reqTurmas.Add(req.Aula.TurmaId.Id);
TurmaBO turma = new TurmaBO();
List<Turma> listaTurma = turma.GetTurmas(cal);
listaTurma.Sort();
if (listaTurma.Count == 0)
{
lblStatus.Text = "Nenhuma turma cadastrada.";
lblStatus.Visible = true;
}
else
{
// Turmas sem solicitações de recursos, não teóricas e não de pós
List<TurmaVerifica> turmasRecursos = new List<TurmaVerifica>();
// Turmas restantes (todas as outras)
List<TurmaVerifica> turmasRestante = new List<TurmaVerifica>();
// Total de turmas restantes
int totalTurmasRestante = 0;
// Total de turmas que deveriam solicitar recursos
int totalTurmasRecursos = 0;
// Total de turmas com falta de preenchimento em algum aspecto
int totalRestanteFalta = 0;
// Total de turmas sem solicitação de recursos
int totalRecursosFalta = 0;
foreach (Turma t in listaTurma)
{
TurmaVerifica nova = new TurmaVerifica
{
Id = t.Id,
Numero = t.Numero,
Calendario = t.Calendario,
Disciplina = t.Disciplina,
DataHora = t.DataHora,
Professor = t.Professor,
Curso = t.Curso
};
// "teorica" representa turmas teóricas ou de algum pós
bool teorica = nova.Disciplina.Categoria.Descricao.Contains("Teórica") ||
nova.Disciplina.Categoria.Descricao.Contains("PPG") ||
nova.Curso.Nome.Contains("PPG") ||
nova.Curso.Nome.StartsWith("Física");
// Se a turma não é "teórica", ela deveria solicitar recursos
if (!teorica)
totalTurmasRecursos++;
else
// Caso contrário, conta nas demais
totalTurmasRestante++;
// Verifica o preenchimento dos dados, retorna true se
// a turma está incompleta
if (verificaTurma(ref nova, t.Disciplina.G2))
{
// Se a turma deveria solicitar recursos e não o fez,
// conta mais uma e adiciona na lista de pendentes
if (nova.RecursosOK == "NÃO" && !teorica)
{
turmasRecursos.Add(nova);
totalRecursosFalta++;
}
// Se a turma não precisa solicitar recursos, conta
// nas restantes e adiciona na lista
if(teorica)
{
turmasRestante.Add(nova);
totalRestanteFalta++;
}
}
}
// Calcula os percentuais
double percRecursos = totalRecursosFalta / (double)totalTurmasRecursos;
lblPercentualRecursos.Text = String.Format("Turmas sem solicitações de recursos (excluindo teóricas e pós): {1} de {2} ({0:P})", percRecursos, totalRecursosFalta, totalTurmasRecursos);
double percPreench = totalRestanteFalta / (double)totalTurmasRestante;
lblPercentualGeral.Text = String.Format("Demais turmas com pendências: {1} de {2} ({0:P})", percPreench, totalRestanteFalta, totalTurmasRestante);
grvListaTurmas.RowDataBound += grvListaTurmas_RowDataBound;
grvListaTurmas.DataSource = turmasRecursos;
grvListaTurmas.DataBind();
grvListaTurmasGeral.RowDataBound += grvListaTurmasGeral_RowDataBound;
grvListaTurmasGeral.DataSource = turmasRestante;
grvListaTurmasGeral.DataBind();
}
}
catch (BusinessData.DataAccess.DataAccessException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
catch (Exception ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
}
public void UpdateCalendario(Calendario calendario)
{
DbCommand cmd = baseDados.GetStoredProcCommand("CalendariosUpdate");
baseDados.AddInParameter(cmd, "@CalendarioId", DbType.Guid, calendario.Id);
baseDados.AddInParameter(cmd, "@Semestre", DbType.Int32, calendario.Semestre);
baseDados.AddInParameter(cmd, "@Ano", DbType.Int32, calendario.Ano);
baseDados.AddInParameter(cmd, "@InicioG1", DbType.DateTime, calendario.InicioG1);
baseDados.AddInParameter(cmd, "@InicioG2", DbType.DateTime, calendario.InicioG2);
baseDados.AddInParameter(cmd, "@FimG2", DbType.DateTime, calendario.FimG2);
try
{
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public List<Disciplina> GetDisciplinas(Calendario calendario)
{
try
{
return dao.GetDisciplinas(calendario);
}
catch (DataAccessException )
{
throw;
}
}
public List<Alocacao> GetAlocacoesSemData(Calendario cal, Guid recursoId)
{
return dao.GetAlocacoesSemData(cal, recursoId);
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!IsPostBack)
{
if (Session["AppState"] != null && ((AppState)Session["AppState"]) == AppState.Admin)
{
Server.Transfer("~/Default/Erro.aspx?Erro=O sistema está bloqueado.");
}
//else if ((AppState)Session["AppState"] != AppState.Requisicoes)
// Server.Transfer("~/Default/Erro.aspx?Erro=Os recursos já foram distribuídos.");
else
{
if (Session["Calendario"] == null)
{
Response.Redirect("../Default/SelecionarCalendario.aspx");
}
Guid idturma = new Guid();
if (Request.QueryString["GUID"] != null)
{
try
{
idturma = new Guid(Request.QueryString["GUID"]);
}
catch (FormatException)
{
Response.Redirect("~/Default/Erro.aspx?Erro=Codigo de turma inválido!");
}
Session["TurmaId"] = idturma;
cal = (Calendario)Session["Calendario"];
CategoriaAtividadeBO cateBO = new CategoriaAtividadeBO();
listaAtividades = cateBO.GetCategoriaAtividade();
AulaBO AulaBO = new AulaBO();
List<Aula> listaAulas = null;
try
{
listaAulas = AulaBO.GetAulas(idturma);
}
catch (Exception)
{
Response.Redirect("~/Default/Erro.aspx?Erro=Codigo de turma inválido!");
}
foreach (Aula a in listaAulas)
{
categorias.Add(a.CategoriaAtividade.Id);
argb.Add(a.CategoriaAtividade.Cor);
}
Disciplina disc = listaAulas[0].TurmaId.Disciplina;
CategoriaDisciplina cat = disc.Categoria;
//lblTitulo.text += " " + cat.Descricao;
// Mega gambiarra master extended++
// TODO: retirar assim que possível!
if(cat.Descricao.IndexOf("Outras Unidades") != -1)
facin = false;
lblTitulo.Text = listaAulas[0].TurmaId.Disciplina.Nome + " - Turma " + listaAulas[0].TurmaId.Numero;//+ " " + facin;
Session["facin"] = facin;
dgAulas.DataSource = listaAulas;
dgAulas.DataBind();
}
}
}
}
catch (DataAccessException ex)
{
Response.Redirect("~/Default/Erro.aspx?Erro=" + ex.Message);
}
}
public List<Alocacao> GetAlocacoes(Calendario cal, DateTime data, Secretario secretario)
{
return dao.GetAlocacoes(cal, data, secretario);
}
public List<Alocacao> GetAlocacoes(Calendario cal, DateTime data, Guid recursoId)
{
return dao.GetAlocacoes(cal, data, recursoId);
}
public List<Alocacao> GetAlocacoes(Calendario cal, DateTime data, Professor prof)
{
return dao.GetAlocacoes(cal, data, prof);
}
public List<Alocacao> GetAlocacoesSemData(Calendario cal, Secretario secretario)
{
return dao.GetAlocacoesSemData(cal, secretario);
}
public List<Alocacao> GetAlocacoesSemData(Calendario cal, Professor prof)
{
return dao.GetAlocacoesSemData(cal, prof);
}
public void CriarAulas(Calendario cal, Turma t)
{
try
{
//ordena lista da datas
cal.Datas.Sort();
//Recebe a lista das turmas
TurmaBO contadorroleTurmas = new TurmaBO();
IList<Entities.Turma> listaTurmas = contadorroleTurmas.GetTurmas(cal);
Util.DataHelper dheper = new BusinessData.Util.DataHelper();
//Recebe a lista das atividades
CategoriaAtividadeBO contadorroleAtividades = new CategoriaAtividadeBO();
IList<CategoriaAtividade> listaAtividades = contadorroleAtividades.GetCategoriaAtividade();
if (listaAtividades.Count == 0)
{
throw new IndexOutOfRangeException();
}
CategoriaAtividade cat = listaAtividades[0];
foreach (CategoriaAtividade categoria in listaAtividades)
{
if (categoria.Descricao.Equals("Aula"))
cat = categoria;
}
AulaBO contadorroleAulas = new AulaBO();
Aula aulaAux;
string horario = t.DataHora;
//dado um horario pucrs(2ab,4cd), exclui os horarios e guarda os dias em array de inteiros
string diasPucrs = Regex.Replace(horario, "[a-zA-Z]", String.Empty);
int tamanho = diasPucrs.Length;
int[] dias = new int[tamanho];
for (int i = 0; i < tamanho; i++)
{
dias[i] = Convert.ToInt32(diasPucrs.Substring(i, 1));
}
string[] horariosPucrs = horario.Split(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }, StringSplitOptions.RemoveEmptyEntries);
DateTime aux = cal.InicioG1;
while (aux <= cal.FimG2)
{
for (int i = 0; i < dias.Length; i++)
{
if ((int)(aux.DayOfWeek) == (dias[i] - 1))
{
aulaAux = Aula.newAula(t, horariosPucrs[i], aux, string.Empty, cat);
this.InsereAula(aulaAux);
}
}
aux = aux.AddDays(1);
}
}
catch (DataAccessException ex)
{
throw ex;
}
}
