/*Obtiene los generos de una banda especifica
*/
public List <generos> obtenerGenerosBanda(bandas banda)
{
List <generos> obj = new List <generos>();
try
{
using (myconcertEntities context = new myconcertEntities())
{
var aType = context.generos.Join(context.generosbanda,
g => g.PK_generos,
gb => gb.FK_GENEROSBANDA_GENEROS,
(g, gb) => new { g, gb })
.Where(f => f.gb.FK_GENEROSBANDA_BANDAS == banda.PK_bandas).
Select(s => new { PK_generos = s.g.PK_generos,
genero = s.g.genero }).ToList();
foreach (var i in aType)
{
obj.Add(context.generos.FirstOrDefault(g => g.PK_generos == i.PK_generos));
}
}
}
catch (Exception ex)
{
throw (ex);
}
return(obj);
}
public bool comprobarBandaEnCartelera(DateTime fInicial, DateTime fFinal, bandas banda)
{
int conteo = 0;;
try
{
using (myconcertEntities context = new myconcertEntities())
{
conteo = context.eventos.Join(context.categoriasevento,
e => e.PK_eventos,
ce => ce.FK_CATEGORIASEVENTO_EVENTOS,
(e, ce) => new { e, ce })
.Where(w => w.ce.FK_CATEGORIASEVENTO_BANDAS == banda.PK_bandas)
.Select(s => s.e)
.Count(c => c.fechaInicio <fInicial && c.fechaFinal> fInicial || c.fechaInicio <fFinal && c.fechaFinal> fFinal);
}
if (conteo == 0)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception e)
{
throw (e);
}
}
public bandas updatebandas(Banda pBanda)
{
string nombre = pBanda.Nombre;
int estado = _manejadorDB.obtenerEstado(pBanda.Estado).PK_estados;
bandas ban = new bandas();
ban.FK_BANDAS_ESTADOS = estado;
ban.nombreBan = nombre;
return(ban);
}
public Banda createBanda(bandas pBanda)
{
int id = pBanda.PK_bandas;
string nombre = pBanda.nombreBan;
float calificacion = _manejadorDB.getCalificacion(pBanda);
string estado = _manejadorDB.obtenerEstado(pBanda.FK_BANDAS_ESTADOS).estado;
Banda ban = new Banda(id, nombre, calificacion, estado);
return(ban);
}
//Conseguir bandas no seleccionadas de una cartelera convertida a festival
public List <bandas> extraerBandasNoSeleccionadas(List <bandas> bandasGanadorasFestival, List <bandas> todasBandasCartelera)
{
foreach (bandas bandaGanadora in bandasGanadorasFestival)
{
bandas bandaEliminar = todasBandasCartelera.Find(x => x.nombreBan.Equals(bandaGanadora.nombreBan));
if (bandaEliminar != null)
{
todasBandasCartelera.Remove(bandaEliminar);
}
}
return(todasBandasCartelera);
}
//Comprueba si banda esta en lista
public bool existeEnLista(List <bandas> lista, bandas pBanda)
{
foreach (bandas bandActual in lista)
{
if (pBanda.nombreBan == bandActual.nombreBan)
{
//Retorna que banda se encuentra en lista
return(true);
}
}
//Retorna que banda no está en la lista
return(false);
}
//Registrar nueva banda en el sistema
public Respuesta nuevaBanda(string pNombre, JArray pMiembros,
JArray pCanciones, JArray pGeneros)
{
Respuesta respuesta = null;
Banda banda = new Banda(pNombre, _manejador.obtenerEstado(1).estado);
string[] miembros = _serial.getArrayString(pMiembros);
if (miembros.Length < 1)
{
return(_fabricaRespuestas.crearRespuesta(false, "Debe ingresar al menos un integrante de banda."));
}
string[] canciones = _serial.getArrayString(pCanciones);
if (canciones.Length < 3)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error, se ingresaron menos de las 3 canciones mínimas para banda nueva. Por favor intente nuevo."));
}
else if (canciones.Length > 10)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error, se ingresaron más de 10 canciones máximas. Por favor intente con menos."));
}
int[] generos = _serial.getArrayInt(pGeneros);
if (generos.Length > 10 || generos.Length < 1)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error: Se deben seleccionar de 1 a 10 géneros musicales. Por favor intente con 10 o menos."));
}
//Almacena banda nueva
try
{
bandas bandaNueva = _manejador.obtenerBanda(banda.Nombre);
if (bandaNueva != null)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error: Banda ya existente. Por favor intente de nuevo."));
}
_manejador.añadirBanda(_convertidor.updatebandas(banda),
_convertidor.updateintegrantes(miembros),
_convertidor.updatecanciones(canciones),
_convertidor.updateListaGeneros(generos));
respuesta = _fabricaRespuestas.crearRespuesta(true, "Banda registrada correctamente.");
} catch (Exception)
{
//Retorna respuesta de error
respuesta = _fabricaRespuestas.crearRespuesta(false, "Fallo al ingresar banda o banda ya existente.");
//respuesta = _fabricaRespuestas.crearRespuesta(false, "Fallo al ingresar banda o banda ya esxistente.", e.ToString());
}
return(respuesta);
}
/*Obtiene una banda del nombre deseado
*/
public bandas obtenerBanda(string banda)
{
bandas obj = null;
try
{
using (myconcertEntities context = new myconcertEntities())
{
obj = context.bandas.FirstOrDefault(r => r.nombreBan == banda);
}
}
catch (Exception ex)
{
throw (ex);
}
return(obj);
}
/*Obtiene los comentarios de una banda especifica
*/
public List <comentarios> obtenerComentarios(bandas banda)
{
List <comentarios> obj = null;
try
{
using (myconcertEntities context = new myconcertEntities())
{
obj = context.comentarios.Where(i => i.FK_COMENTARIOS_BANDAS == banda.PK_bandas).ToList();
}
}
catch (Exception ex)
{
throw (ex);
}
return(obj);
}
/*Obtiene los integrantes de una banda especifica
*/
public List <integrantes> obtenerIntegrantes(bandas banda)
{
List <integrantes> obj = null;
try
{
using (myconcertEntities context = new myconcertEntities())
{
obj = context.integrantes.Where(i => i.FK_INTEGRANTES_BANDAS == banda.PK_bandas).ToList();
}
}
catch (Exception ex)
{
throw (ex);
}
return(obj);
}
/*Obtiene la lista de canciones de una banda especifica
*/
public List <canciones> obtenerCanciones(bandas banda)
{
List <canciones> obj = null;
try
{
using (myconcertEntities context = new myconcertEntities())
{
obj = context.canciones.Where(r => r.FK_CANCIONES_BANDAS == banda.PK_bandas).ToList();
}
}
catch (Exception ex)
{
throw (ex);
}
return(obj);
}
/*
*/
public float getCalificacion(bandas banda)
{
float calificacion = 0;
try
{
using (myconcertEntities context = new myconcertEntities())
{
calificacion = (float)context.comentarios.Where(r => r.FK_COMENTARIOS_BANDAS == banda.PK_bandas).Average(r => r.calificacion);
}
return(calificacion);
}
catch (Exception)
{
return(calificacion);
}
}
/*
*/
public int getCantidadComentarios(bandas banda)
{
int cantidadComen = 0;
try
{
using (myconcertEntities context = new myconcertEntities())
{
cantidadComen = context.comentarios.Count(r => r.FK_COMENTARIOS_BANDAS == banda.PK_bandas);
}
}
catch (Exception ex)
{
throw (ex);
}
return(cantidadComen);
}
{ //DB = base de datos
/*Añade una banda a la DB
* Realiza una transacción en caso de que alguna solicitud falle, de esta manera solo añade la banda si todos
* los demas elementos que pertenecen a la banda son añadidos
*/
public void añadirBanda(bandas banda, List <integrantes> integ, List <canciones> can, List <generos> gen)
{
using (myconcertEntities context = new myconcertEntities())
{
using (var dbContextTransaction = context.Database.BeginTransaction())
{
try
{
banda = context.bandas.Add(banda);
foreach (integrantes i in integ)
{
i.FK_INTEGRANTES_BANDAS = banda.PK_bandas;
context.integrantes.Add(i);
}
foreach (canciones c in can)
{
c.FK_CANCIONES_BANDAS = banda.PK_bandas;
context.canciones.Add(c);
}
foreach (generos g in gen)
{
generosbanda gB = new generosbanda
{
FK_GENEROSBANDA_BANDAS = banda.PK_bandas,
FK_GENEROSBANDA_GENEROS = g.PK_generos
};
context.generosbanda.Add(gB);
}
context.SaveChanges();
dbContextTransaction.Commit();
}
catch (Exception ex)
{
dbContextTransaction.Rollback();
throw (ex);
}
}
}
}
public void extraerBandasNoSeleccionadasTest()
{
List <bandas> listaTotal = new List <bandas>();
bandas banda1 = new bandas();
bandas banda2 = new bandas();
banda1.nombreBan = "Romare";
banda2.nombreBan = "Nicolas Jaar";
listaTotal.Add(banda1);
listaTotal.Add(banda2);
List <bandas> listaGanadores = new List <bandas>();
bandas banda3 = new bandas();
banda3.nombreBan = "Romare";
listaGanadores.Add(banda3);
List <bandas> listaPerdedores = _model.extraerBandasNoSeleccionadas(listaGanadores, listaTotal);
Assert.AreEqual(listaPerdedores[0].nombreBan, banda2.nombreBan);
}
public void bandasToStringTest()
{
List <bandas> lista = new List <bandas>();
bandas banda1 = new bandas();
bandas banda2 = new bandas();
banda1.nombreBan = "Romare";
banda2.nombreBan = "Nicolas Jaar";
lista.Add(banda1);
lista.Add(banda2);
bandas[] arrayBanda = lista.ToArray();
List <string> listaRespuesta = _model.bandasToString(lista);
string[] arrayString = listaRespuesta.ToArray();
for (int i = 0; i < arrayBanda.Length; i++)
{
StringAssert.Equals(arrayBanda[i], arrayString[i]);
}
}
public eventos updateeventos(Festival pEvento)
{
eventos event_feste = new eventos();
event_feste.PK_eventos = pEvento.Id;
event_feste.nombreEve = pEvento.Nombre;
event_feste.ubicacion = pEvento.Ubicacion;
event_feste.FK_EVENTOS_PAISES = _manejadorDB.obtenerPais(pEvento.Pais).PK_paises;
event_feste.fechaInicio = pEvento.FechaInicioFestival;
event_feste.fechaFinal = pEvento.FechaInicioFestival;
event_feste.ubicacion = pEvento.Ubicacion;
event_feste.transporte = pEvento.Transporte;
event_feste.servicios = pEvento.Servicios;
event_feste.comida = pEvento.Comida;
bandas banda = _manejadorDB.obtenerBanda(pEvento.RecomendacionChef);
event_feste.FK_EVENTOS_BANDAS_CHEF = banda == null ? 0 : banda.PK_bandas;
event_feste.FK_EVENTOS_TIPOSEVENTOS = _manejadorDB.obtenerTipoEvento(pEvento.TipoEvento).PK_tiposEventos;
event_feste.FK_EVENTOS_ESTADOS = _manejadorDB.obtenerEstado(pEvento.Estado).PK_estados;
return(event_feste);
}
/*
*/
public List <bandas> obtenerBandasNoCartelera(eventos cartelera)
{
List <bandas> bandasCarte = null;
string query = @"SELECT B.PK_bandas, B.nombreBan, B.FK_BANDAS_ESTADOS " +
"FROM bandas as B INNER JOIN categoriasevento as CE " +
"on CE.FK_CATEGORIASEVENTO_BANDAS = B.PK_bandas " +
"where CE.FK_CATEGORIASEVENTO_EVENTOS = ?PK_eventos";
MySqlParameter[] parameters =
{
new MySqlParameter("?PK_eventos", cartelera.PK_eventos)
};
List <bandas> bandasTotal = null;
try
{
using (myconcertEntities context = new myconcertEntities())
{
bandasCarte = context.bandas.SqlQuery(query, parameters).ToList <bandas>();
bandasTotal = context.bandas.ToList();
foreach (bandas bandaCartelera in bandasCarte)
{
bandas bandaEliminar = bandasTotal.Find(x => x.nombreBan.Equals(bandaCartelera.nombreBan));
if (bandaEliminar != null)
{
bandasTotal.Remove(bandaEliminar);
}
}
}
}
catch (Exception ex)
{
throw (ex);
}
return(bandasTotal);
}
//Crear evento nuevo
public Respuesta crearEvento(string pTipoEvento, JObject pDatosEventoJSON, JArray pListaCategorias)
{
Respuesta respuesta = null;
try
{
string nombreEvento = null;
switch (pTipoEvento)
{
//Si el evento a crear es una cartelera
case "cartelera":
//Verificar si cartelera existe
Cartelera nuevaCartelera = _serial.leerDatosCartelera(pDatosEventoJSON);
nombreEvento = nuevaCartelera.Nombre;
eventos eveAux = _manejador.obtenerEvento(nuevaCartelera.Nombre);
if (eveAux != null)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error: Evento ya existente. Intentar de nuevo por favor."));
}
//Verificar que existan categorias en la cartelera
FestivalCategoriaBanda[] categoriasSerial = _serial.getArrayFestivalCategoriaBanda(pListaCategorias);
if (categoriasSerial.Length == 0)
{
return(_fabricaRespuestas.crearRespuesta(false, "No se puede crear cartelera sin categorías. Por favor intente de nuevo."));
}
//Organiza información para envío
List <categoriasevento> categoriasEvento = _convertidor.updatecategoriasevento(categoriasSerial);
//Verificar existencia de bandas en categoria
foreach (categoriasevento catEve in categoriasEvento)
{
if (_manejador.obtenerBanda(catEve.FK_CATEGORIASEVENTO_BANDAS) == null)
{
string nombreCategoria = _manejador.obtenerCategoria(catEve.FK_CATEGORIASEVENTO_CATEGORIAS).categoria;
return(_fabricaRespuestas.crearRespuesta(false, "No se puede crear una cartelera si " + nombreCategoria
+ " no tiene bandas asociadas. Por favor intente de nuevo."));
}
bandas bandaAuxiliar = _manejador.obtenerBanda(catEve.FK_CATEGORIASEVENTO_BANDAS);
if (_manejador.comprobarBandaEnCartelera(nuevaCartelera.FechaInicioFestival, nuevaCartelera.FechaFinalFestival, bandaAuxiliar))
{
return(_fabricaRespuestas.crearRespuesta(false, "La banda " + bandaAuxiliar.nombreBan + " no se encuentra disponible para las fechas indicadas."));
}
}
//Almacena nuevo evento en persistencia
_manejador.añadirCartelera(_convertidor.updateeventos(nuevaCartelera), categoriasEvento);
//Publicar tweets de bandas agregadas a evento
publicarBandasTwitter(nombreEvento, categoriasEvento);
//Operación completada
respuesta = _fabricaRespuestas.crearRespuesta(true, "Cartelera creada exitosamente.");
break;
//Si el evento a crear es un festival
case "festival":
//Verificar si festival existe
Festival nuevoFestival = _serial.leerDatosFestival(pDatosEventoJSON);
eventos eveAux1 = _manejador.obtenerEvento(nuevoFestival.Nombre);
if (eveAux1 == null)
{
return(_fabricaRespuestas.crearRespuesta(false, "Error: Cartelera no existente. Intentar de nuevo por favor. Se necesita partir de una cartelera para convertir a festival."));
}
FestivalCategoriaBanda[] categoriasFestival = _serial.getArrayFestivalCategoriaBanda(pListaCategorias);
eventos nuevoEvento = _convertidor.updateeventos(nuevoFestival);
//Organiza la información para envío
List <bandas> bandasGanadorasFestival = parseBandas(categoriasFestival);
List <categorias> categoriasCartelera = _manejador.obtenerCategoriasEvento(nuevoEvento.PK_eventos);
List <bandas> todasBandasCartelera = extraerBandasEvento(nuevoEvento, categoriasCartelera);
List <bandas> bandasPerdedoras = extraerBandasNoSeleccionadas(bandasGanadorasFestival, todasBandasCartelera);
Console.WriteLine("*** Cartelera ***");
printList(todasBandasCartelera);
Console.WriteLine("*** Ganadoras ***");
printList(bandasGanadorasFestival);
Console.WriteLine("*** Perdedoras ***");
printList(bandasPerdedoras);
List <string> bandasGanadoras = bandasToString(bandasGanadorasFestival);
List <string> bandasPerdedorasString = bandasToString(bandasPerdedoras);
string bandaRecomendada = _chef.executeChefProcess(bandasGanadoras, bandasGanadorasFestival, nuevoEvento.PK_eventos);
nuevoEvento.FK_EVENTOS_BANDAS_CHEF = _manejador.obtenerBanda(bandaRecomendada).PK_bandas;
//Almacena nuevo evento en persistencia
_manejador.crearFestival(nuevoEvento, bandasPerdedoras);
//Publica tweet de nuevo festival
publicarFestivalNuevoTwitter(nuevoEvento.nombreEve);
//Operación completada
respuesta = _fabricaRespuestas.crearRespuesta(true, "Festival creado exitosamente. Nuestra banda recomendada por el chef para el festival es: " + bandaRecomendada);
break;
default:
//Tipo de evento no existe
respuesta = _fabricaRespuestas.crearRespuesta(false, "Tipo de evento no existente.");
break;
}
} catch (Exception e)
{
//respuesta = _fabricaRespuestas.crearRespuesta(false, "Error al crear evento por falta de información. Verifique los datos ingresados por favor.");
respuesta = _fabricaRespuestas.crearRespuesta(false, "Error al crear evento. Por favor intente de nuevo.", e.ToString());
}
//Retorna respuesta
return(respuesta);
}
