/// <summary>
/// Regresa una lista de las olimpiadas en las que la escuela instanciada
/// fue la escuela sede
/// </summary>
/// <returns>La lista de olimpiadas</returns>
public List <Olimpiada> obtenerOlimpiadasSede()
{
List <Olimpiada> list = new List <Olimpiada>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select numero from Olimpiada where escuela = ");
query.Append(clave);
query.Append(" and clase = ");
// Mientras las OMIS y OMIPS no sean aparte, las sedes se cargan de OMIS
query.Append(Cadenas.comillas(TipoOlimpiada.OMI.ToString().ToLower()));
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
if (table.Rows.Count == 0)
{
return(list);
}
foreach (DataRow r in table.Rows)
{
string numero = DataRowParser.ToString(r[0]);
Olimpiada o = Olimpiada.obtenerOlimpiadaConClave(numero, TipoOlimpiada.OMI);
list.Add(o);
}
return(list);
}
/// <summary>
/// Dado que las olimpiadas son pocas y a que se hacen muchas llamadas a la base para obtener estos objetos
/// los cargamos una vez por aplicacion y los dejamos ahi
/// </summary>
/// <returns></returns>
private static Dictionary <string, Olimpiada> getOlimpiadas(TipoOlimpiada tipoOlimpiada)
{
Dictionary <string, Olimpiada> olimpiadas;
string application = obtenerApplicationString(tipoOlimpiada);
olimpiadas = (Dictionary <string, Olimpiada>)HttpContext.Current.Application[application];
if (olimpiadas == null)
{
olimpiadas = cargarOlimpiadas(tipoOlimpiada);
HttpContext.Current.Application[application] = olimpiadas;
// Cargamos las instrucciones en caso de que haya un scoreboard activo
List <OmegaUp> polls = OmegaUp.obtenerInstrucciones(OmegaUp.Instruccion.POLL);
foreach (OmegaUp p in polls)
{
if (p.tipoOlimpiada == tipoOlimpiada)
{
Olimpiada o = Olimpiada.obtenerOlimpiadaConClave(p.olimpiada, p.tipoOlimpiada);
o.liveResults = true;
}
}
}
return(olimpiadas);
}
private void llenarDatos(int usuario, TipoOlimpiada tipoOlimpiada = TipoOlimpiada.OMI)
{
// Primero obtenemos la persona
this.persona = Persona.obtenerPersonaConClave(usuario);
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select olimpiada, medalla, estado from Resultados where concursante = ");
query.Append(usuario);
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipoOlimpiada.ToString().ToLower()));
query.Append(" order by medalla");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
medallas = new List <KeyValuePair <Olimpiada, Resultados.TipoMedalla> >();
estados = new HashSet <string>();
foreach (DataRow r in table.Rows)
{
Resultados.TipoMedalla medalla = DataRowParser.ToTipoMedalla(DataRowParser.ToString(r["medalla"]));
if (medalla == Resultados.TipoMedalla.NADA)
{
continue;
}
Olimpiada o = Olimpiada.obtenerOlimpiadaConClave(DataRowParser.ToString(r["olimpiada"]), tipoOlimpiada);
medallas.Add(new KeyValuePair <Olimpiada, Resultados.TipoMedalla>(o, medalla));
string estado = DataRowParser.ToString(r["estado"]);
if (!estados.Contains(estado))
{
estados.Add(estado);
}
if (medalla == Resultados.TipoMedalla.BRONCE)
{
bronces++;
}
else if (medalla == Resultados.TipoMedalla.PLATA)
{
platas++;
}
else
{
oros++;
}
}
}
/// <summary>
/// Usa las variables en el objeto para calcular las medallas basadas en lo que hay en la base de datos
/// </summary>
/// </param name="tipoOlimpiada">El tipo de olimpiada para el que se requieren los tipos</param>
public static void calcularMedallas(TipoOlimpiada tipoOlimpiada, string olimpiada, bool ordenarPorPuntos)
{
if (tipoOlimpiada == TipoOlimpiada.NULL)
{
return;
}
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" delete medallero where clase = ");
query.Append(Cadenas.comillas(tipoOlimpiada.ToString().ToLower()));
query.Append(" and (tipo <> ");
query.Append((int)TipoMedallero.ESTADO_POR_OMI);
query.Append(" or clave like '%_");
query.Append(olimpiada);
query.Append("%')");
// Primero borramos todo lo que está en la base de datos
// a excepción de otros tipos de olimpiada u otros estado-olimpiada
db.EjecutarQuery(query.ToString());
// Obtenermos todos los resultados
List <Resultados> resultados = Resultados.cargarResultados(null, tipoOlimpiada, cargarObjetos: true);
// Diccionarios para los diferentes tipos de medalleros
Dictionary <int, Medallero> personas = new Dictionary <int, Medallero>();
Dictionary <int, Medallero> instituciones = new Dictionary <int, Medallero>();
Dictionary <string, Medallero> estados = new Dictionary <string, Medallero>();
Dictionary <string, Medallero> estadosPorOlimpiada = new Dictionary <string, Medallero>();
// Recorremos todos los resultados agregando contadores
foreach (Resultados resultado in resultados)
{
Medallero persona;
Medallero institucion;
Medallero estado;
Medallero estadoPorOlimpiada = null;
bool aplicaAOlimpiada = olimpiada == resultado.omi;
string estadoPorOlimpiadaClave = resultado.estado + "_" + resultado.omi;
if (!personas.TryGetValue(resultado.usuario, out persona))
{
persona = new Medallero();
persona.clave = resultado.usuario.ToString();
persona.tipoOlimpiada = tipoOlimpiada;
persona.tipoMedallero = TipoMedallero.PERSONA;
personas.Add(resultado.usuario, persona);
}
if (resultado.escuela != null)
{
if (!instituciones.TryGetValue(resultado.escuela.clave, out institucion))
{
institucion = new Medallero();
institucion.clave = resultado.escuela.clave.ToString();
institucion.tipoOlimpiada = tipoOlimpiada;
institucion.tipoMedallero = TipoMedallero.INSTITUCION;
instituciones.Add(resultado.escuela.clave, institucion);
}
}
else
{
// Agregamos un dummy para evitar if's abajo
institucion = new Medallero();
}
Estado e = Estado.obtenerEstadoConClave(resultado.estado);
if (!estados.TryGetValue(resultado.estado, out estado))
{
estado = new Medallero();
estado.clave = resultado.estado;
estado.tipoOlimpiada = tipoOlimpiada;
estado.tipoMedallero = TipoMedallero.ESTADO;
estados.Add(resultado.estado, estado);
}
if (aplicaAOlimpiada)
{
if (!estadosPorOlimpiada.TryGetValue(estadoPorOlimpiadaClave, out estadoPorOlimpiada))
{
estadoPorOlimpiada = new Medallero();
estadoPorOlimpiada.clave = estadoPorOlimpiadaClave;
estadoPorOlimpiada.tipoOlimpiada = tipoOlimpiada;
estadoPorOlimpiada.omi = resultado.omi;
estadoPorOlimpiada.ordenarPorPuntos = ordenarPorPuntos;
estadoPorOlimpiada.tipoMedallero = TipoMedallero.ESTADO_POR_OMI;
estadoPorOlimpiada.count = 0;
estadoPorOlimpiada.puntos = 0;
estadoPorOlimpiada.promedio = 0;
estadoPorOlimpiada.hayUNKs = false;
if (!e.extranjero)
{
estadosPorOlimpiada.Add(estadoPorOlimpiadaClave, estadoPorOlimpiada);
}
}
}
if (resultado.medalla != Resultados.TipoMedalla.DESCALIFICADO)
{
switch (resultado.medalla)
{
case Resultados.TipoMedalla.ORO_3:
case Resultados.TipoMedalla.ORO_2:
case Resultados.TipoMedalla.ORO_1:
case Resultados.TipoMedalla.ORO:
{
persona.oros++;
estado.oros++;
institucion.oros++;
if (aplicaAOlimpiada)
{
estadoPorOlimpiada.oros++;
}
break;
}
case Resultados.TipoMedalla.PLATA:
{
persona.platas++;
estado.platas++;
institucion.platas++;
if (aplicaAOlimpiada)
{
estadoPorOlimpiada.platas++;
}
break;
}
case Resultados.TipoMedalla.BRONCE:
{
persona.bronces++;
estado.bronces++;
institucion.bronces++;
if (aplicaAOlimpiada)
{
estadoPorOlimpiada.bronces++;
}
break;
}
default:
{
persona.otros++;
estado.otros++;
institucion.otros++;
break;
}
}
if (aplicaAOlimpiada)
{
if (resultado.clave.StartsWith(Resultados.CLAVE_DESCONOCIDA))
{
estadoPorOlimpiada.hayUNKs = true;
}
// No se han guardado mas de 4 lugares
if (estadoPorOlimpiada.count < 4)
{
// En algunas olimpiadas, hubo invitados que se pusieron en el medallero, estos no se cuentan en el total
if (!resultado.clave.EndsWith("I"))
{
Olimpiada o = Olimpiada.obtenerOlimpiadaConClave(resultado.omi, resultado.tipoOlimpiada);
// Si solo tenemos los datos de los medallistas, no podemos hacer nada con los puntos
if (o.noMedallistasConocidos)
{
// En las OMIs con puntos desconocidos, se guarda en los puntos del día 2, los puntos de los estados
if (o.puntosDesconocidos)
{
estadoPorOlimpiada.puntos += resultado.totalDia2;
}
else
{
estadoPorOlimpiada.count++;
estadoPorOlimpiada.puntos += resultado.total;
}
}
}
}
}
}
}
// Guardamos los contadores en la base de datos
// Primero las personas
foreach (Medallero persona in personas.Values)
{
if (persona.clave != "0")
{
persona.guardarDatos();
}
}
// Después las instituciones
foreach (Medallero institucion in instituciones.Values)
{
if (institucion.clave != "0")
{
institucion.guardarDatos();
}
}
// Los estados (general)
foreach (Medallero estado in estados.Values)
{
estado.guardarDatos();
}
// Finalmente, para los estados por olimpiada, hay que hacer un par de cosas
List <Medallero> sortedEstados = new List <Medallero>(estadosPorOlimpiada.Values);
if (sortedEstados.Count > 0)
{
string lastOMI = sortedEstados[0].omi;
bool invalido = false;
int firstEstadoInOmi = 0;
// Los necesitamos ordenados primero por olimpiada
sortedEstados.Sort();
// Necesitamos reordenarlos por promedio
for (int i = 0; i < sortedEstados.Count; i++)
{
Medallero estado = sortedEstados[i];
if (estado.omi != lastOMI)
{
// Si algún estado en la olimpiada tiene un
// promedio invalido, ningún promedio es valido
if (invalido)
{
for (int j = firstEstadoInOmi; j < i; j++)
{
sortedEstados[j].promedio = 0;
}
}
firstEstadoInOmi = i;
invalido = false;
lastOMI = estado.omi;
}
if (!estado.hayUNKs && estado.count > 0)
{
estado.promedio = (float?)Math.Round((double)(estado.puntos / estado.count), 2);
}
invalido |= estado.promedioEsInvalido();
}
sortedEstados.Sort();
lastOMI = "";
int lugarActual = 0;
Medallero ultimoEstado = null;
// Vamos por cada estado para asignarles el lugar
foreach (Medallero estado in sortedEstados)
{
// Estamos recibiendo los estados de todas las olimpiadas
if (estado.omi != lastOMI)
{
lastOMI = estado.omi;
lugarActual = 0;
ultimoEstado = null;
}
lugarActual++;
// Revisamos si hay empates entre estados
if (ultimoEstado == null ||
ultimoEstado.oros != estado.oros ||
ultimoEstado.platas != estado.platas ||
ultimoEstado.bronces != estado.bronces ||
(int)Math.Round((double)ultimoEstado.puntos) != (int)Math.Round((double)estado.puntos))
{
estado.lugar = lugarActual;
}
else
{
estado.lugar = ultimoEstado.lugar;
}
ultimoEstado = estado;
estado.guardarDatos();
}
}
// Al final hacemos los ajustes hardcodeados
hardcode(tipoOlimpiada, olimpiada);
}