/// <summary>
/// Calcula los estados de los cuales hay participantes para la persona
/// </summary>
/// <param name="tipoOlimpiada">El tipo de olimpiada</param>
public List <string> consultarEstados(TipoOlimpiada tipoOlimpiada = TipoOlimpiada.NULL)
{
List <string> estados = new List <string>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select distinct(estado) from MiembroDelegacion where persona = ");
query.Append(this.clave);
if (tipoOlimpiada != TipoOlimpiada.NULL)
{
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipoOlimpiada.ToString().ToLower()));
}
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
estados = new List <string>();
foreach (DataRow r in table.Rows)
{
string estado = DataRowParser.ToString(r[0]);
estados.Add(estado);
}
return(estados);
}
public void BuildRouteParameters_Parses_Different_Types_From_Path_Parts(string methodName, string pathPart, string culture, object rawExpected)
{
using (new CultureSwap(culture)) {
var route = Route_Tests.CreateRoute(typeof(PathPartTypeController), methodName);
_RouteMapper.Initialise(new Route[] { route });
_Environment.SetRequestPath(new string[] { route.PathParts[0].Part, pathPart });
var parameters = _RouteMapper.BuildRouteParameters(route, _Environment.Environment);
var expected = rawExpected;
switch (methodName)
{
case nameof(PathPartTypeController.DateTimePP): expected = DataRowParser.DateTime((string)expected); break;
case nameof(PathPartTypeController.DateTimeOffsetPP): expected = DataRowParser.DateTimeOffset((string)expected); break;
}
Assert.IsTrue(parameters.IsValid);
Assert.AreEqual(1, parameters.Parameters.Length);
var actual = parameters.Parameters[0];
if (actual is byte[] byteArray)
{
var expectedByteArray = (byte[])expected;
Assert.IsTrue(expectedByteArray.SequenceEqual(byteArray));
}
else
{
Assert.AreEqual(expected, parameters.Parameters[0]);
}
}
}
private void llenarDatos(DataRow r)
{
clave = DataRowParser.ToInt(r["clave"]);
log = DataRowParser.ToString(r["log"]);
tipo = DataRowParser.ToTipoLog(r["tipo"]);
timestamp = DataRowParser.ToLongDateTime(r["timestamp"]);
}
/// <summary>
/// Regresa la lista de resultados para el problema seleccionado
/// </summary>
/// <param name="olimpiada">La olimpiada del problema</param>
/// <param name="tipo">El tipo de olimpiada</param>
/// <param name="dia">El dia del problema</param>
/// <param name="numero">El id del problema</param>
/// <returns>La lista ordenada de resultados</returns>
public static List <float> obtenerResultadosParaProblema(string olimpiada, TipoOlimpiada tipo, int dia, int numero)
{
List <float> resultados = new List <float>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
string puntos = "puntosD" + dia + "P" + numero;
query.Append(" select ");
query.Append(puntos);
query.Append(" from resultados where olimpiada = ");
query.Append(Cadenas.comillas(olimpiada));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" order by ");
query.Append(puntos);
query.Append(" asc ");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
foreach (DataRow r in table.Rows)
{
resultados.Add(DataRowParser.ToStrictFloat(r[0]));
}
return(resultados);
}
/// <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>
/// Obtiene los multimedallistas de la olimpiada mandada como parámetro
/// </summary>
/// <param name="tipoOlimpiada">El tipo de olimpiada</param>
/// <param name="cabeceras">El número de cabeceras que tendrá la tabla</param>
/// <param name="excluirNoOros">true si solamente debemos incluir aquellos
/// medallistas con al menos 1 oro</param>
/// <param name="estado">Si debemos filtrar a cierto estado en particular</param>
/// <returns>La lista de competidores con múltiples medallas</returns>
public static List <HallOfFamer> obtenerMultimedallistas(out int cabeceras, TipoOlimpiada tipoOlimpiada = TipoOlimpiada.OMI, bool excluirNoOros = true, string estado = null)
{
List <HallOfFamer> medallistas = new List <HallOfFamer>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select clave from Medallero where tipo = ");
query.Append((int)Medallero.TipoMedallero.PERSONA);
query.Append(" and ");
if (excluirNoOros)
{
query.Append(" oro > 0 and ");
}
query.Append(" (oro + plata + bronce) > 1 and clase = ");
query.Append(Cadenas.comillas(tipoOlimpiada.ToString().ToLower()));
query.Append(" order by oro desc, plata desc, bronce desc");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
HallOfFamer lastHof = null;
cabeceras = 0;
int lugar = 0;
foreach (DataRow r in table.Rows)
{
HallOfFamer hof = new HallOfFamer();
hof.llenarDatos(DataRowParser.ToInt(r["clave"].ToString()));
if (estado != null)
{
if (!hof.estados.Contains(estado))
{
continue;
}
}
lugar++;
if (lastHof == null || lastHof.oros != hof.oros ||
lastHof.platas != hof.platas || lastHof.bronces != hof.bronces)
{
hof.lugar = lugar;
}
else
{
hof.lugar = lastHof.lugar;
}
if (hof.medallas.Count > cabeceras)
{
cabeceras = hof.medallas.Count;
}
lastHof = hof;
medallistas.Add(hof);
}
return(medallistas);
}
public void FormatGuid_Formats_Guid(string inputText, string culture, string expected)
{
using (new CultureSwap(culture)) {
var input = DataRowParser.Guid(inputText);
var actual = Formatter.FormatGuid(input);
Assert.AreEqual(expected, actual);
}
}
private void llenarDatos(DataRow r)
{
album = DataRowParser.ToString(r["album"]);
id = DataRowParser.ToString(r["id"]);
orden = DataRowParser.ToInt(r["orden"]);
imagen = DataRowParser.ToString(r["imagen"]);
url = DataRowParser.ToString(r["url"]);
}
public void FormatDateTimeOffset_Formats_DateTime(string inputText, string culture, string expected)
{
using (new CultureSwap(culture)) {
var input = DataRowParser.DateTimeOffset(inputText);
var actual = Formatter.FormatDateTimeOffset(input);
Assert.AreEqual(expected, actual);
}
}
public void FormatType_Without_Resolver_Formats_Objects(Type objectType, string inputText, string culture, string expected)
{
var inputValue = DataRowParser.ConvertExpected(objectType, inputText);
using (new CultureSwap(culture)) {
var actual = Formatter.FormatType(inputValue);
Assert.AreEqual(expected, actual);
}
}
private static void llenarDatos(DataRow row, OverlayPuntos puntos, int problemas)
{
puntos.timestamp.Add(DataRowParser.ToInt(row["timestamp"]));
for (int i = 0; i < problemas; i++)
{
puntos.problemas[i].Add(DataRowParser.ToFloat(row["puntosP" + (i + 1)]));
}
puntos.puntos.Add(DataRowParser.ToFloat(row["puntosD"]));
}
/// <summary>
/// Actualiza la última entrada en la tabla para el concursante mandado como parámetro
/// </summary>
public static void actualizarUltimo(string omi, TipoOlimpiada tipo, int dia, string clave, List <float?> puntos, float?total)
{
StringBuilder query = new StringBuilder();
Acceso db = new Acceso();
// Primero obtenemos el timestamp mas grande
query.Append(" select MAX(timestamp) from DetallePuntos where olimpiada = ");
query.Append(Cadenas.comillas(omi));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" and clave = ");
query.Append(Cadenas.comillas(clave));
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
if (table.Rows.Count == 0)
{
return;
}
int timestamp = DataRowParser.ToInt(table.Rows[0][0]);
query.Clear();
// Ahora actualizamos los puntos
query.Append("update DetallePuntos set puntosP1 = ");
query.Append(puntos[0] == null ? "0" : puntos[0].ToString());
query.Append(", puntosP2 = ");
query.Append(puntos[1] == null ? "0" : puntos[1].ToString());
query.Append(", puntosP3 = ");
query.Append(puntos[2] == null ? "0" : puntos[2].ToString());
query.Append(", puntosP4 = ");
query.Append(puntos[3] == null ? "0" : puntos[3].ToString());
query.Append(", puntosP5 = ");
query.Append(puntos[4] == null ? "0" : puntos[4].ToString());
query.Append(", puntosP6 = ");
query.Append(puntos[5] == null ? "0" : puntos[5].ToString());
query.Append(", puntosD = ");
query.Append(total == null ? "0" : total.ToString());
query.Append(" where olimpiada = ");
query.Append(Cadenas.comillas(omi));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" and clave = ");
query.Append(Cadenas.comillas(clave));
query.Append(" and timestamp = ");
query.Append(timestamp);
db.EjecutarQuery(query.ToString());
}
public static void clean(string omi, TipoOlimpiada tipo, int dia)
{
StringBuilder query = new StringBuilder();
Acceso db = new Acceso();
query.Append(" select * from DetalleLugar where olimpiada = ");
query.Append(Cadenas.comillas(omi));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" order by clave, timestamp asc ");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
bool first = false;
DetalleLugar anterior = new DetalleLugar();
DetalleLugar actual = new DetalleLugar();
foreach (DataRow r in table.Rows)
{
actual.lugar = DataRowParser.ToInt(r["lugar"]);
actual.timestamp = DataRowParser.ToInt(r["timestamp"]);
actual.medalla = DataRowParser.ToTipoMedalla(r["medalla"]);
actual.clave = DataRowParser.ToString(r["clave"]);
if (actual.clave != anterior.clave)
{
first = true;
}
else
{
if (actual.medalla == anterior.medalla &&
actual.lugar == anterior.lugar)
{
if (!first)
{
borrar(omi, tipo.ToString().ToLower(), anterior.clave, anterior.timestamp, dia);
}
first = false;
}
else
{
first = true;
}
}
anterior.lugar = actual.lugar;
anterior.timestamp = actual.timestamp;
anterior.medalla = actual.medalla;
anterior.clave = actual.clave;
}
}
private void llenarDatos(DataRow row)
{
clave = DataRowParser.ToString(row["clave"]);
timestamp = DataRowParser.ToInt(row["timestamp"]);
puntosProblemas = new List <float?>();
for (int i = 0; i < 6; i++)
{
puntosProblemas.Add(DataRowParser.ToFloat(row["puntosP" + (i + 1)]));
}
puntosDia = DataRowParser.ToFloat(row["puntosD"]);
}
public void Format_Behaves_Correctly(string culture, string rawValue, string expected)
{
using (new CultureSwap(culture)) {
var value = DataRowParser.DateTimeOffset(rawValue).Value;
var formatter = new DateTimeOffset_MicrosoftJson_Formatter();
var actual = formatter.Format(value);
Assert.AreEqual(expected, actual);
}
}
public void Format_Behaves_Correctly(string rawValue, string expected)
{
using (new CultureSwap("en-GB")) {
var value = DataRowParser.DateTime(rawValue).Value;
var formatter = new DateTime_Iso8601_Formatter();
var actual = formatter.Format(value);
Assert.AreEqual(expected, actual);
}
}
[DataRow("en-GB", "2019-07-01T17:42:32.123+0800", true, "2019-07-01 17:42:32.123 +0800")] // Local timezone specified
public void TryParse_Behaves_Correctly(string culture, string text, bool expectedResult, string expectedValueText)
{
using (new CultureSwap(culture)) {
var parser = new DateTimeOffset_Local_Parser();
var actualResult = parser.TryParse(text, out var actualValue);
var expectedValue = DataRowParser.DateTimeOffset(expectedValueText);
Assert.AreEqual(expectedResult, actualResult);
Assert.AreEqual(expectedValue, actualValue);
}
}
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++;
}
}
}
private void llenarDatos(DataRow datos, bool cargarUsuario = false)
{
clave = DataRowParser.ToInt(datos["clave"]);
tipo = DataRowParser.ToTipoPeticion(datos["tipo"]);
subtipo = DataRowParser.ToTipoPeticion(datos["subtipo"]);
datos1 = DataRowParser.ToString(datos["datos1"]);
datos2 = DataRowParser.ToString(datos["datos2"]);
datos3 = DataRowParser.ToString(datos["datos3"]);
if (cargarUsuario)
{
usuario = Persona.obtenerPersonaConClave(DataRowParser.ToInt(datos["usuario"]));
}
}
public void BuildModel_QueryStringDictionary_Can_Parse_All_Native_Types(string propertyName, string value, object expected, string culture)
{
using (new CultureSwap(culture)) {
var propertyInfo = typeof(AllNativeTypes).GetProperty(propertyName);
var dictionary = new QueryStringDictionary($"{propertyName}={value ?? ""}");
var model = _ModelBuilder.BuildModel(typeof(AllNativeTypes), null, dictionary) as AllNativeTypes;
var actual = propertyInfo.GetValue(model, null);
expected = DataRowParser.ConvertExpected(propertyInfo.PropertyType, expected);
Assert.AreEqual(expected, actual);
}
}
/// <summary>
/// Calcula las participaciones diferente a competidor que tiene la persona
/// </summary>
/// <param name="tipoOlimpiada">El tipo de olimpiada</param>
public List <string> consultarParticipaciones(TipoOlimpiada tipoOlimpiada = TipoOlimpiada.NULL)
{
List <string> tipos = new List <string>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select distinct(tipo) from MiembroDelegacion where persona = ");
query.Append(this.clave);
query.Append(" and tipo != ");
query.Append(Cadenas.comillas(MiembroDelegacion.TipoAsistente.COMPETIDOR.ToString().ToLower()));
if (tipoOlimpiada != TipoOlimpiada.NULL)
{
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipoOlimpiada.ToString().ToLower()));
}
query.Append(" and clase <> ");
query.Append(Cadenas.comillas(TipoOlimpiada.OMIPO.ToString().ToLower()));
query.Append(" and clase <> ");
query.Append(Cadenas.comillas(TipoOlimpiada.OMISO.ToString().ToLower()));
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
tipos = new List <string>();
foreach (DataRow r in table.Rows)
{
MiembroDelegacion.TipoAsistente tipo = DataRowParser.ToTipoAsistente(DataRowParser.ToString(r[0]));
if (tipo == MiembroDelegacion.TipoAsistente.DELELIDER)
{
if (!tipos.Contains(MiembroDelegacion.TipoAsistente.LIDER.ToString()))
{
tipos.Add(MiembroDelegacion.TipoAsistente.LIDER.ToString());
}
if (!tipos.Contains(MiembroDelegacion.TipoAsistente.DELEGADO.ToString()))
{
tipos.Add(MiembroDelegacion.TipoAsistente.DELEGADO.ToString());
}
}
else
{
string t = MiembroDelegacion.getTipoAsistenteString(tipo);
if (!tipos.Contains(t))
{
tipos.Add(t);
}
}
}
return(tipos);
}
/// <summary>
/// Actualiza la última entrada en la tabla para el concursante mandado como parámetro
/// </summary>
public static void actualizarUltimo(string omi, TipoOlimpiada tipo, int dia, string clave, int lugar, Resultados.TipoMedalla medalla)
{
StringBuilder query = new StringBuilder();
Acceso db = new Acceso();
// Primero obtenemos el timestamp mas grande
query.Append(" select MAX(timestamp) from DetalleLugar where olimpiada = ");
query.Append(Cadenas.comillas(omi));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" and clave = ");
query.Append(Cadenas.comillas(clave));
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
if (table.Rows.Count == 0)
{
return;
}
int timestamp = DataRowParser.ToInt(table.Rows[0][0]);
query.Clear();
// Ahora actualizamos los puntos
query.Append("update DetalleLugar set lugar = ");
query.Append(lugar);
if (medalla != Resultados.TipoMedalla.DESCALIFICADO)
{
query.Append(", medalla = ");
query.Append((int)medalla);
}
query.Append(" where olimpiada = ");
query.Append(Cadenas.comillas(omi));
query.Append(" and clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" and clave = ");
query.Append(Cadenas.comillas(clave));
query.Append(" and timestamp = ");
query.Append(timestamp);
db.EjecutarQuery(query.ToString());
}
public void llenarDatos(DataRow datos)
{
tipoOlimpiada = DataRowParser.ToTipoOlimpiada(datos["clase"]);
tipoMedallero = DataRowParser.ToTipoMedallero(datos["tipo"]);
clave = DataRowParser.ToString(datos["clave"]);
oros = DataRowParser.ToInt(datos["oro"]);
platas = DataRowParser.ToInt(datos["plata"]);
bronces = DataRowParser.ToInt(datos["bronce"]);
otros = DataRowParser.ToInt(datos["otros"]);
puntos = DataRowParser.ToFloat(datos["puntos"]);
promedio = DataRowParser.ToFloat(datos["promedio"]);
lugar = DataRowParser.ToInt(datos["lugar"]);
omi = DataRowParser.ToString(datos["omi"]);
}
private void llenarDatos(DataRow datos)
{
olimpiada = DataRowParser.ToString(datos["olimpiada"]);
tipoOlimpiada = DataRowParser.ToTipoOlimpiada(datos["clase"]);
dia = DataRowParser.ToInt(datos["dia"]);
numero = DataRowParser.ToInt(datos["numero"]);
nombre = DataRowParser.ToString(datos["nombre"]);
url = DataRowParser.ToString(datos["url"]);
media = DataRowParser.ToStrictFloat(datos["media"]);
perfectos = DataRowParser.ToInt(datos["perfectos"]);
ceros = DataRowParser.ToInt(datos["ceros"]);
mediana = DataRowParser.ToStrictFloat(datos["mediana"]);
casos = DataRowParser.ToString(datos["casos"]);
codigo = DataRowParser.ToString(datos["codigo"]);
solucion = DataRowParser.ToString(datos["solucion"]);
}
public void ReturnJsonObject_Returns_Simple_Values_Correctly(Type type, object value, string expectedBody)
{
var route = Route_Tests.CreateRoute <Controller>(nameof(Controller.IntMethod));
_Environment.Environment[WebApiEnvironmentKey.Route] = route;
using (new CultureSwap("en-GB")) {
var parsedValue = DataRowParser.ConvertExpected(type, value);
_Responder.ReturnJsonObject(_Environment.Environment, parsedValue);
Assert.AreEqual("application/json; charset=utf-8", _Environment.ResponseHeadersDictionary["Content-Type"]);
Assert.AreEqual(expectedBody.Length.ToString(CultureInfo.InvariantCulture), _Environment.ResponseHeadersDictionary["Content-Length"]);
Assert.AreEqual(expectedBody, _Environment.ResponseBodyText);
}
}
public void llenarDatos(DataRow r)
{
clave = DataRowParser.ToInt(r["clave"]);
nombre = DataRowParser.ToString(r["nombre"]);
omi = DataRowParser.ToString(r["olimpiada"]);
tipoOlimpiada = DataRowParser.ToTipoOlimpiada(r["clase"]);
estado = DataRowParser.ToString(r["estado"]);
supervisor = DataRowParser.ToString(r["supervisor"]);
telefono = DataRowParser.ToString(r["telefono"]);
correo = DataRowParser.ToString(r["correo"]);
supervisor2 = DataRowParser.ToString(r["supervisor2"]);
telefono2 = DataRowParser.ToString(r["telefono2"]);
correo2 = DataRowParser.ToString(r["correo2"]);
supervisor3 = DataRowParser.ToString(r["supervisor3"]);
telefono3 = DataRowParser.ToString(r["telefono3"]);
correo3 = DataRowParser.ToString(r["correo3"]);
}
private void llenarDatos(DataRow datos)
{
clave = DataRowParser.ToString(datos["clave"]);
nombre = DataRowParser.ToString(datos["nombre"]);
sitio = DataRowParser.ToString(datos["sitio"]);
ISO = DataRowParser.ToString(datos["iso"]);
extranjero = DataRowParser.ToBool(datos["ext"]);
claveDelegado = DataRowParser.ToInt(datos["delegado"]);
delegado = Persona.obtenerPersonaConClave(claveDelegado);
if (delegado != null)
{
nombreDelegado = delegado.nombreCompleto;
usuarioDelegado = delegado.usuario;
mailDelegado = delegado.correo;
}
}
public static int obtenerTimestampMasReciente(string clave, TipoOlimpiada tipo, int dia)
{
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select top 1 timestamp from detallepuntos ");
query.Append(" where clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
query.Append(" and olimpiada = ");
query.Append(Cadenas.comillas(clave));
query.Append(" and dia = ");
query.Append(dia);
query.Append(" order by timestamp desc ");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
return(DataRowParser.ToInt(table.Rows[0][0]));
}
private void llenarDatos(DataRow r)
{
id = DataRowParser.ToString(r["id"]);
lastUpdated = DataRowParser.ToDateTime(r["lastUpdated"]);
orden = DataRowParser.ToInt(r["orden"]);
// Los datos generales no guardan nada mas
if (id == ALBUM_GRAL)
{
return;
}
olimpiada = DataRowParser.ToString(r["olimpiada"]);
tipoOlimpiada = DataRowParser.ToTipoOlimpiada(r["clase"]);
fotos = DataRowParser.ToInt(r["fotos"]);
nombre = DataRowParser.ToString(r["nombre"]);
portada = DataRowParser.ToString(r["portada"]);
newsletter = DataRowParser.ToBool(r["newsletter"]);
}
/// <summary>
/// Obtiene una lista de todas las olimpiadas con albumes de fotos
/// </summary>
/// <param name="tipo">El tipo de olimpiada</param>
/// <returns>La lista de olimpiadas</returns>
public static HashSet <string> obtenerOlimpiadasConAlbumes(TipoOlimpiada tipo = TipoOlimpiada.OMI)
{
HashSet <string> olimpiadas = new HashSet <string>();
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
query.Append(" select distinct(olimpiada) from album where clase = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
foreach (DataRow row in table.Rows)
{
olimpiadas.Add(DataRowParser.ToString(row[0]));
}
return(olimpiadas);
}