protected void btnConfirmar_Click(object sender, EventArgs e)
{
RequisicoesBO req = new RequisicoesBO();
foreach (DecoratorRequisicoes dec in listaRequisicoes)
{
switch (dec.EstadoAtual)
{
case DecoratorRequisicoes.EstadoRequisicao.Inserida:
req.InsereRequisicao(dec);
break;
case DecoratorRequisicoes.EstadoRequisicao.Removida:
req.DeletaRequisicao(dec.IdRequisicao);
break;
case DecoratorRequisicoes.EstadoRequisicao.Atualizada:
req.UpdateRequisicoes(dec);
break;
}
}
limparSessao = true;
FechaJanela();
}
protected void ddlRecurso_SelectedIndexChanged(object sender, EventArgs e)
{
DropDownList ddlRecurso = (DropDownList) sender;
string recString = ddlRecurso.SelectedValue;
TableCell cell = (TableCell) ddlRecurso.Parent;
DataGridItem gridItem = (DataGridItem) cell.Parent;
// Salva dados digitados
SalvarTodos();
// SalvaDados(gridItem);
// abre a popup de selecao de recursos
//string id = lblaulaId.Text;
//ScriptManager.RegisterClientScriptBlock(this, GetType(), "onClick", "popitup('SelecaoRecursos.aspx?AulaId=" + id + "');", true);
Label lblaulaId = (Label) gridItem.FindControl("lblAulaId");
Guid idAula = new Guid(lblaulaId.Text);
Aula aulaAtual = aulaBo.GetAulaById(idAula);
RequisicoesBO controleRequisicoes = new RequisicoesBO();
IList<Requisicao> requisicoesExistentes = controleRequisicoes.GetRequisicoesPorAula(idAula, cal);
int pri = 0;
foreach (Requisicao req in requisicoesExistentes)
if (req.Prioridade > pri)
pri = req.Prioridade;
CategoriaRecursoBO controladorCategorias = new CategoriaRecursoBO();
Guid catId = new Guid(ddlRecurso.SelectedValue);
CategoriaRecurso categoria = controladorCategorias.GetCategoriaRecursoById(catId);
Requisicao novaReq = Requisicao.NewRequisicao(aulaAtual, categoria, pri+1); // teste! sempre prioridade + 1
// Insere a nova requisição
controleRequisicoes.InsereRequisicao(novaReq);
requisicoesExistentes.Add(novaReq);
// Atualiza label com os recursos selecionados
Label lblRecursosSelecionados = (Label) gridItem.FindControl("lblRecursosSelecionados");
string recursos = "";
foreach (Requisicao r in requisicoesExistentes)
{
if (recursos != String.Empty) recursos += "<br/>";
recursos += r.Prioridade + ": " + r.CategoriaRecurso.Descricao;
}
lblRecursosSelecionados.Text = recursos;
// Remove a categoria selecionada do drop down list
ddlRecurso.Items.Remove(ddlRecurso.Items.FindByValue(ddlRecurso.SelectedValue));
ddlRecurso.SelectedIndex = 0;
}
public void DistribuirRecursos(int ano, int semestre, bool simula)
{
ControleCalendario calendarios = new ControleCalendario();
ControleRequisicoes controleRequisicoes = new ControleRequisicoes();
ColecaoRequisicoes requisicoes;
Calendario calAtual = calendarios.GetCalendario(ano, semestre);
Debug.WriteLine("Calendario: " + calAtual.EntidadeCalendario.PorExtenso);
Random rand = new Random();
double soma = 0.0;
Dictionary <TurmaDistribuicao, SatisfacaoTurma> satTurmas = new Dictionary <TurmaDistribuicao, SatisfacaoTurma>();
//Preenche a colecao para todas as turmas do semestre
// Debug.WriteLine("Criando coleção de satisfação de turmas...");
foreach (TurmaDistribuicao t in calAtual.Turmas)
{
satTurmas.Add(t, new SatisfacaoTurma(t));
}
int maxPri = 0;
foreach (Requisicao r in calAtual.Requisicoes)
{
if (r.Prioridade > maxPri)
{
maxPri = r.Prioridade;
}
}
Debug.WriteLine("Prioridade máxima: " + maxPri);
AlocacaoBO controleAloc = new AlocacaoBO();
List <BusinessData.Entities.Alocacao> todasAloc = controleAloc.GetAlocacoes(calAtual.InicioG1);
// HashSet<String> indisponiveis = new HashSet<string>();
Dictionary <string, string> convHorario = new Dictionary <string, string>
{
{ "A", "AB" }, { "B", "AB" },
{ "C", "CD" }, { "D", "CD" },
{ "E", "EX" }, { "X", "EX" },
{ "F", "FG" }, { "G", "FG" },
{ "H", "HI" }, { "I", "HI" },
{ "J", "JK" }, { "K", "JK" },
{ "L", "LM" }, { "M", "LM" },
{ "N", "NP" }, { "P", "NP" }
};
Dictionary <String, List <BusinessData.Entities.Recurso> > indisponiveis = new Dictionary <string, List <BusinessData.Entities.Recurso> >();
foreach (BusinessData.Entities.Alocacao aloc in todasAloc)
{
string key = aloc.Data.ToString() + convHorario[aloc.Horario.ToString()];
List <BusinessData.Entities.Recurso> recursosDiaHora = null;
if (indisponiveis.ContainsKey(key))
{
recursosDiaHora = indisponiveis[key];
}
else
{
recursosDiaHora = new List <BusinessData.Entities.Recurso>();
}
recursosDiaHora.Add(aloc.Recurso);
indisponiveis[key] = recursosDiaHora;
//Debug.WriteLine(key);
}
//return;
//Para cada prioridade de requisicao
for (int prioridadePedidos = 1; prioridadePedidos <= maxPri; /*calAtual.Categorias.Count*/ prioridadePedidos++)
{
Debug.WriteLine("Prioridade: " + prioridadePedidos + " de " + maxPri);//calAtual.Categorias.Count);
foreach (CategoriaRecurso cat in calAtual.Categorias)
{
//Inicializa os dados
Debug.WriteLine("\n\n **************** Categoria: " + cat.Descricao + "\n\n");
foreach (TurmaDistribuicao turma in calAtual.Turmas)
{
satTurmas[turma].Atendimentos = 0;
satTurmas[turma].Pedidos = 0;
satTurmas[turma].Prioridade = 0;
}
Debug.WriteLine("Obtendo requisições para categoria e prioridade...");
requisicoes = calAtual.Requisicoes.GetRequisicoes(prioridadePedidos, cat, calAtual.Dias);
soma = 0.0;
double prioridadeAux = 0.0;
List <double> listaPrioridadesAux = new List <double>();
Debug.WriteLine("Calculando total de requisições para as turmas...");
//Calcula o numero de requisicoes para as turmas
foreach (Requisicao req in requisicoes)
{
satTurmas[req.Turma].Pedidos++;
//Calcula o total para a normalizacao
prioridadeAux = req.Turma.EntidadeTurma.Disciplina.Categoria.Prioridades[cat.EntidadeCategoria];
if (!listaPrioridadesAux.Contains(prioridadeAux))
{
soma += prioridadeAux;
listaPrioridadesAux.Add(prioridadeAux);
}
}
//Normaliza as prioridades entre categorias de disciplina e categorias de recurso atual para
//um total de 100%
Debug.WriteLine("Normalizando prioridades...");
foreach (Requisicao req in requisicoes)
{
prioridadeAux = req.Turma.EntidadeTurma.Disciplina.Categoria.Prioridades[req.CategoriaRecurso.EntidadeCategoria];
satTurmas[req.Turma].Prioridade = prioridadeAux / soma;
}
Debug.WriteLine("*** PROCESSAMENTO DOS DIAS ***");
int totalDias = calAtual.Dias.Count;
int curDia = 1;
foreach (Dia dia in calAtual.Dias)
{
//if(curDia++ % 30 == 0)
Debug.WriteLine(">>> Dia: " + dia.Data);
foreach (Horarios.HorariosPUCRS horario in dia.Horarios)
{
//Debug.WriteLine("Horario: " + horario.ToString());
// Todos os recursos disponíveis nesta categoria, dia e horário
//Debug.WriteLine(" Obtendo recursos disponíveis (sem filtrar)");
List <Recurso> auxRecursosDisponiveis = cat.GetRecursosDisponiveis(dia.Data, horario.ToString());
// Todas as requisições neste dia e horário
//Debug.WriteLine(" Obtendo requisições neste dia e horário...");
IList <Requisicao> reqDiaHoraGeral = calAtual.Requisicoes.GetRequisicoes(dia.Data, horario);
// Lista para armazenar os REALMENTE disponíveis
// (depois de remover as dependências de salas duplas, etc)
List <Recurso> recursosDisponiveis = new List <Recurso>();
//Debug.WriteLine(" Removendo recursos bloqueados por dependências...");
foreach (Recurso rec in auxRecursosDisponiveis)
{
bool bloqueado = false;
foreach (Requisicao req in reqDiaHoraGeral)
{
if (req.Recurso == null)
{
continue; // Não alocado, não interfere
}
Guid bloqueia1 = req.Recurso.Bloqueia1;
Guid bloqueia2 = req.Recurso.Bloqueia2;
// Se o recurso alocado é um dos que bloqueiam
// este...
if (rec.EntidadeRecurso.Id == bloqueia1 ||
rec.EntidadeRecurso.Id == bloqueia2)
{
// Não podemos utilizá-lo!
//Debug.WriteLine("!!! Recurso " + rec.EntidadeRecurso.Descricao + " bloqueado por dependência");
bloqueado = true;
break;
}
}
// Verifica se já existe reserva para evento previamente alocada
string key = dia.Data.ToString() + horario.ToString();
if (indisponiveis.ContainsKey(key))
{
List <BusinessData.Entities.Recurso> listaRecsHorario = indisponiveis[key];
foreach (var recT in listaRecsHorario)
{
// Recurso já alocado para evento?
if (recT.Descricao.Equals(rec.EntidadeRecurso.Descricao))
{
bloqueado = true;
break;
}
}
}
if (!bloqueado)
{
recursosDisponiveis.Add(rec);
}
}
IList <Requisicao> requisicoesDiaHora = requisicoes.GetRequisicoes(dia.Data, horario);
// Se houver recursos suficientes para atender os pedidos
// entrega um para cada
if (requisicoesDiaHora.Count <= recursosDisponiveis.Count)
{
//Debug.WriteLine(" Atendendo TODOS os pedidos deste dia e horário!");
for (int i = 0; i < requisicoesDiaHora.Count; i++)
{
recursosDisponiveis[i].Aloca(dia.Data, horario.ToString(), requisicoesDiaHora[i].Turma);
satTurmas[requisicoesDiaHora[i].Turma].Atendimentos++;
requisicoesDiaHora[i].EstaAtendido = true;
requisicoesDiaHora[i].Recurso = recursosDisponiveis[i].EntidadeRecurso;
/*
* Não precisa: são os mesmos objetos nas duas listas
* foreach(Requisicao reqGeral in reqDiaHoraGeral)
* if(reqGeral.Id == requisicoesDiaHora[i].Id)
* {
* reqGeral.Recurso = recursosDisponiveis[i].EntidadeRecurso;
* }
*/
}
}
else
{
//Debug.WriteLine(" Tentando atender...");
SortedList <double, List <Requisicao> > listaPrioridades = new SortedList <double, List <Requisicao> >();
double prioridadeSelecionada = 0.0;
//Cria os Conjuntos prioridade/Requisicao
foreach (Requisicao req in requisicoesDiaHora)
{
//prioridadeSelecionada = req.Turma.EntidadeTurma.Disciplina.Categoria.Prioridades[cat.EntidadeCategoria];
prioridadeSelecionada = satTurmas[req.Turma].Prioridade;
if (!listaPrioridades.Keys.Contains(prioridadeSelecionada))
{
listaPrioridades.Add(prioridadeSelecionada, new List <Requisicao>());
}
listaPrioridades[prioridadeSelecionada].Add(req);
}
foreach (Recurso rec in recursosDisponiveis)
{
#region Sorteia em qual conjunto irá efetuar a distribuicao
double sorteado = rand.NextDouble();
prioridadeSelecionada = double.PositiveInfinity;
//Se for o primeiro item da lista
if (sorteado <= listaPrioridades.Keys[0])
{
prioridadeSelecionada = listaPrioridades.Keys[0];
}
else
{
for (int i = 1; i < listaPrioridades.Keys.Count - 1; i++)
{
if (sorteado <= listaPrioridades.Keys[i] + listaPrioridades.Keys[i - 1])
{
prioridadeSelecionada = listaPrioridades.Keys[i];
}
}
}
//se for o ultimo da lista
if (prioridadeSelecionada == double.PositiveInfinity)
{
prioridadeSelecionada = listaPrioridades.Keys[listaPrioridades.Keys.Count - 1];
}
//-----------------------------------------------------------
#endregion
double satMin = 1;
double best = double.PositiveInfinity;
foreach (Requisicao req in listaPrioridades[prioridadeSelecionada])
{
if (satTurmas[req.Turma].Satisfacao < satMin)
{
satMin = satTurmas[req.Turma].Satisfacao;
}
}
TurmaDistribuicao turmaEscolhida = null;
Requisicao reqEscolhida = null;
foreach (Requisicao req in listaPrioridades[prioridadeSelecionada])
{
//Se a satisfacao da turma atual foi a menor e ela fez o menor numero de pedidos é selecionada
if ((satTurmas[req.Turma].Satisfacao == satMin) && (satTurmas[req.Turma].Pedidos < best))
{
best = satTurmas[req.Turma].Pedidos;
turmaEscolhida = req.Turma;
reqEscolhida = req;
}
}
//Atende uma requisicao
//Debug.WriteLine(" >>> Atendendo:" + rec.EntidadeRecurso.Descricao);
rec.Aloca(dia.Data, horario.ToString(), turmaEscolhida);
satTurmas[turmaEscolhida].Atendimentos++;
reqEscolhida.EstaAtendido = true;
reqEscolhida.Recurso = rec.EntidadeRecurso;
/* Não precisa: são os mesmos objetos nas
* duas listas
* // Atualiza a lista geral deste dia e horário
* foreach (Requisicao reqGeral in reqDiaHoraGeral)
* if (reqGeral.Id == reqEscolhida.Id)
* {
* reqGeral.Recurso = rec.EntidadeRecurso;
* }
*/
//Remove requisicao do grupo de requisicoes
listaPrioridades[prioridadeSelecionada].Remove(reqEscolhida);
//Se nao houverem mais requisicoes no grupo selecionado,o remove
if (listaPrioridades[prioridadeSelecionada].Count == 0)
{
listaPrioridades.Remove(prioridadeSelecionada);
}
}
}
}
}
}
}
Debug.WriteLine("");
Debug.WriteLine("*** FIM DO PROCESSAMENTO ***");
Debug.WriteLine("");
//Persiste as alocacoes na base de dados
BusinessData.BusinessLogic.AlocacaoBO controleAlocacoes = new BusinessData.BusinessLogic.AlocacaoBO();
foreach (CategoriaRecurso catRec in calAtual.Categorias)
{
foreach (Recurso rec in catRec)
{
Debug.WriteLine("Recurso: " + rec.EntidadeRecurso.Descricao);
foreach (BusinessData.Entities.Alocacao aloc in rec.Alocacoes)
{
string aux = "";
if (aloc.Aula != null)
{
aux = aloc.Aula.DescricaoAtividade;
}
else if (aloc.Evento != null)
{
aux = aloc.Evento.Descricao + "(" + aloc.Evento.Responsavel + ")";
}
Debug.WriteLine(" Alocando: " + aloc.Data.ToShortDateString() +
" " + aloc.Horario.ToString() + " - " + aux);
// Se não está simulando, aloca recurso
if (!simula)
{
controleAlocacoes.UpdateAlocacao(aloc);
}
}
}
}
// Salva as requisições para exibir estatísticas no final
HttpContext.Current.Session["ReqResult"] = calAtual.Requisicoes;
// Se está simulando, não há mais nada a fazer
if (simula)
{
return;
}
BusinessData.BusinessLogic.RequisicoesBO cReq = new BusinessData.BusinessLogic.RequisicoesBO();
foreach (Requisicao req in calAtual.Requisicoes)
{
if (req.EstaAtendido)
{
cReq.SetAtendida(req.Id);
}
}
///End
///
//LOG
//instancia o usuario logado
//MembershipUser user = Membership.GetUser();
//instancia o log
//LogEntry log = new LogEntry();
//monta log
//log.Message = "Calendário: " + calAtual.Ano + "/" + calAtual.Semestre + "; Administrador: " + user.UserName;
//log.TimeStamp = DateTime.Now;
//log.Severity = TraceEventType.Information;
//log.Title = "Iniciar Semestre";
//log.MachineName = Dns.GetHostName();
//guarda log no banco
//Logger.Write(log);
}
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);
}
}
}
private void GetRequisicoes()
{
RequisicoesBO controleRequisicoes = new RequisicoesBO();
IList<Requisicao> requisicoesExistentes = controleRequisicoes.GetRequisicoesPorAula(aulaAtual.Id, calendarioAtual);
foreach (Requisicao req in requisicoesExistentes)
{
DecoratorRequisicoes.EstadoRequisicao estado = DecoratorRequisicoes.EstadoRequisicao.Original;
listaRequisicoes.Add(new DecoratorRequisicoes(req, estado));
if (req.Prioridade == Convert.ToInt32(ddlPrioridadeRequisicao.SelectedValue))
{
ddlCategoriaRecurso.SelectedValue = req.CategoriaRecurso.Id.ToString();
}
if (req.Prioridade > ddlPrioridadeRequisicao.Items.Count)
{
if (!estado.ToString().Equals("Removida"))
AdicionaOpcao();
}
}
Session.Add("listaRequisicoes", listaRequisicoes);
}
