public ActionResult Logotipo(long?id = null)
{
IAplicacionesServicio srv = Servicios.AplicacionesServicio();
long appID = id ?? Aplicacion.AplicacionID;
Aplicacion aplicacion = srv.GetSingle(c => c.AplicacionID == appID);
if (aplicacion != null)
{
if (aplicacion.Logotipo == null)
{
return(File("~/Content/Images/PushNewsLogo.png", contentType: "image/png"));
}
else
{
var cd = new ContentDisposition
{
FileName = aplicacion.Logotipo.Nombre,
Inline = false,
};
Response.AppendHeader(name: "Content-Disposition", value: cd.ToString());
FileStream str = FileManager.ObtenerDocumento(aplicacion.Logotipo);
return(new FileStreamResult(str, aplicacion.Logotipo.Mime));
}
}
else
{
return(HttpNotFound());
}
}
public ActionResult ListaAplicaciones()
{
IAplicacionesServicio srv = Servicios.AplicacionesServicio();
IEnumerable <AplicacionGrid> consulta = srv.Get().Select(AplicacionGrid.FromEntity);
return(Json(consulta, JsonRequestBehavior.AllowGet));
}
public ActionResult Leer([DataSourceRequest] DataSourceRequest request)
{
IAplicacionesServicio srv = Servicios.AplicacionesServicio();
IEnumerable <Aplicacion> registros = srv.Get();
IEnumerable <AplicacionGrid> resultado = registros.Select(r => AplicacionGrid.FromEntity(r));
return(Json(resultado.ToDataSourceResult(request), JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Nuevo([DataSourceRequest] DataSourceRequest request, ComunicacionGrid model)
{
DataSourceResult result = new[] { model }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
// Validar la categoría escogida por el usuario
if (CategoriaPermitida(model.CategoriaID))
{
try
{
IAplicacionesServicio appSrv = Servicios.AplicacionesServicio();
Aplicacion app = appSrv.GetSingle(c => c.AplicacionID == Aplicacion.AplicacionID);
bool mantenerUbicacion = app.Caracteristicas.Any(c => c.Nombre == "GeoPosicionamiento");
var srv = Servicios.ComunicacionesServicio();
var nuevo = srv.Create();
model.ActualizarEntidad(nuevo, mantenerUbicacion);
nuevo.UsuarioID = CurrentUserID();
nuevo.Instantanea = model.FechaPublicacion < DateTime.Now;
srv.Insert(nuevo);
await srv.ApplyChangesAsync();
if (nuevo.Instantanea)
{
if (EnviarPush(nuevo))
{
nuevo.PushEnviada = true;
nuevo.PushFecha = DateTime.Now;
await srv.ApplyChangesAsync();
}
else
{
nuevo.Instantanea = false;
await srv.ApplyChangesAsync();
}
}
result = new[]
{
ComunicacionGrid.FromEntity(nuevo, CategoriasPermitidasIds, PeriodoEnvioPushHoras)
}.ToDataSourceResult(request, ModelState);
}
catch (Exception e)
{
log.Error("Error al añadir la comunicación.", e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Aniadir, Txt.Comunicaciones.ArtEntidad).Frase() };
}
}
else
{
log.Warn($"El usuario {Usuario.Nombre} ({Usuario.UsuarioID}) ha intentado crear una comunicación con la categoría {model.CategoriaID} que no tiene asignada.");
result.Errors = new[] { Txt.Comunicaciones.CategoriaNoPermitida };
}
}
return(Json(result));
}
public async Task <ActionResult> Modificar([DataSourceRequest] DataSourceRequest request, AplicacionGrid model)
{
DataSourceResult result = new[] { model }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
try
{
IAplicacionesServicio srv = Servicios.AplicacionesServicio();
Aplicacion modificar = srv.Get()
.SingleOrDefault(r => r.AplicacionID == model.AplicacionID);
if (modificar != null)
{
LoguearCambiosApiKey(modificar, model);
model.ActualizarEntidad(modificar);
ActualizarCaracteristicas(modificar, model.Caracteristicas);
await srv.ApplyChangesAsync();
if (Aplicacion.AplicacionID == modificar.AplicacionID)
{
Session["Aplicacion"] = modificar;
Session["Caracteristicas"] = modificar.Caracteristicas
.Where(c => c.Activo)
.Select(c => (Dominio.Enums.AplicacionCaracteristica)c.AplicacionCaracteristicaID);
}
result = new[] { AplicacionGrid.FromEntity(modificar) }.ToDataSourceResult(request, ModelState);
}
else
{
result.Errors = new[] { string.Format(Txt.ErroresComunes.NoExiste, Txt.Aplicaciones.ArtEntidad).Frase() };
}
}
catch (SubdominioExisteException see)
{
log.Error($"Error al modificar {Txt.Aplicaciones.ArtEntidad} con id {model.AplicacionID}. Usuario: {CurrentUserID()}", see);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar + see.Message, Txt.Aplicaciones.ArtEntidad).Frase() };
}
catch (AplicacionExisteException see)
{
log.Error($"Error al modificar {Txt.Aplicaciones.ArtEntidad} con id {model.AplicacionID}. Usuario: {CurrentUserID()}", see);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar + see.Message, Txt.Aplicaciones.ArtEntidad).Frase() };
}
catch (Exception e)
{
log.Error("Error al modificar " + Txt.Aplicaciones.ArtEntidad + " con id=" + model.AplicacionID, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar, Txt.Aplicaciones.ArtEntidad).Frase() };
}
}
return(Json(result));
}
public async Task <ActionResult> Nuevo([DataSourceRequest] DataSourceRequest request, UsuarioGrid usuario)
{
DataSourceResult result = new[] { usuario }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
bool usuarioActualizado = false;
try
{
IAplicacionesServicio apSrv = Servicios.AplicacionesServicio();
ICategoriasServicio carSrv = Servicios.CategoriasServicio();
IUsuariosServicio empSrv = Servicios.UsuariosServicio();
Usuario usuarioNuevo = empSrv.Create();
usuario.ActualizarEntidad(usuarioNuevo);
usuarioNuevo.Aplicaciones = apSrv.Get(cl => usuario.Aplicaciones.Contains(cl.AplicacionID)).ToList();
IdentityResult ir = await UserManager.CreateAsync(usuarioNuevo, usuario.Clave);
if (ir.Succeeded)
{
result = new[] { UsuarioGrid.FromEntity(usuarioNuevo) }.ToDataSourceResult(request, ModelState);
usuarioActualizado = true;
await UserManager.EstablecerRol(usuarioNuevo, usuario.PerfilID);
result = new[] { UsuarioGrid.FromEntity(usuarioNuevo) }.ToDataSourceResult(request, ModelState);
}
else
{
foreach (var error in ir.Errors)
{
ModelState.AddModelError("", error);
}
result = new[] { usuario }.ToDataSourceResult(request, ModelState);
}
}
catch (Exception e)
{
if (usuarioActualizado)
{
log.Error($"Error al establecer perfiles del usuario creado {usuario.Email}", e);
result.Errors = new[] { string.Format(Txt.Usuarios.ErrorEstablecerPerfiles, usuario.Email).Frase() };
}
else
{
log.Error("Error al añadir el usuario " + usuario.Nombre, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Aniadir, Txt.Usuarios.ArtEntidad).Frase() };
}
}
}
return(Json(result));
}
public async Task <ActionResult> Nuevo([DataSourceRequest] DataSourceRequest request, AplicacionGrid model)
{
DataSourceResult result = new[] { model }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
try
{
IAplicacionesServicio srv = Servicios.AplicacionesServicio();
Aplicacion nueva = srv.Create();
model.ActualizarEntidad(nueva);
if (model.Caracteristicas != null && model.Caracteristicas.Any())
{
IAplicacionesCaracteristicasServicio acSrv = Servicios.AplicacionesCaracteristicasServicio();
nueva.Caracteristicas.AddRange(acSrv.Get(ca => model.Caracteristicas.Contains(ca.AplicacionCaracteristicaID)));
}
srv.Insert(nueva);
await srv.ApplyChangesAsync();
result = new[] { AplicacionGrid.FromEntity(nueva) }.ToDataSourceResult(request, ModelState);
}
catch (SubdominioExisteException see)
{
log.Error($"Error al añadir {Txt.Aplicaciones.ArtEntidad}. Usuario: {CurrentUserID()}", see);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar + see.Message, Txt.Aplicaciones.ArtEntidad).Frase() };
}
catch (AplicacionExisteException see)
{
log.Error($"Error al modificar {Txt.Aplicaciones.ArtEntidad}. Usuario: {CurrentUserID()}", see);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar + see.Message, Txt.Aplicaciones.ArtEntidad).Frase() };
}
catch (Exception e)
{
log.Error("Error al añadir " + Txt.Aplicaciones.ArtEntidad + " " + model.Nombre, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Aniadir, Txt.Aplicaciones.ArtEntidad).Frase() };
}
}
return(Json(result));
}
public async Task <ActionResult> CrearModificar(ComunicacionGrid model)
{
object result;
try
{
if (ModelState.IsValid)
{
// Validar la categoría escogida por el usuario
if (CategoriaPermitida(model.CategoriaID))
{
IAplicacionesServicio appSrv = Servicios.AplicacionesServicio();
Aplicacion app = appSrv.GetSingle(c => c.AplicacionID == Aplicacion.AplicacionID);
bool mantenerUbicacion = app.Caracteristicas.Any(c => c.Nombre == "GeoPosicionamiento");
var srv = Servicios.ComunicacionesServicio();
if (model.ComunicacionID != 0)
{
var modificar = srv.GetSingle(p => p.ComunicacionID == model.ComunicacionID);
if (modificar != null)
{
// Verificar que el usuario está autorizado a gestionar la comunicación,
// por la categoría original a la que pertenece.
if (CategoriaPermitida(modificar.CategoriaID))
{
// Guardar en variables aparte los ids de adjunto e imagen, por si hay que
// eliminarlos.
long?documentoEliminar = null, imagenEliminar = null;
if (model.AdjuntoDocumentoID == null)
{
documentoEliminar = modificar.AdjuntoDocumentoID;
}
if (model.ImagenDocumentoID == null)
{
imagenEliminar = modificar.ImagenDocumentoID;
}
model.ActualizarEntidad(modificar, mantenerUbicacion);
await srv.ApplyChangesAsync();
result = ComunicacionGrid.FromEntity(modificar, CategoriasPermitidasIds, PeriodoEnvioPushHoras);
// La eliminación de documentos (registro de la tabla Documentos y fichero de
// disco) se realiza después de haber actualizado la comunicación (poner FK a
// null) para garantizar que la comunicación se actualiza aunque falle la
// la eliminación en disco. Si hubiera fallos, quedaría el registro de documento
// sin ninguna comunicación que lo enlace, así como el archivo en disco.
if (documentoEliminar.HasValue)
{
try
{
await FileManager.EliminarDocumento(documentoEliminar.Value);
}
catch (Exception e)
{
log.Error($"Error al eliminar documento {documentoEliminar.Value} durante la modificación de su comunicación asociada.", e);
}
}
if (imagenEliminar.HasValue)
{
try
{
await FileManager.EliminarDocumento(imagenEliminar.Value);
}
catch (Exception e)
{
log.Error($"Error al eliminar imagen {imagenEliminar.Value} durante la modificación de su comunicación asociada.", e);
}
}
}
else
{
result = new
{
Errors = new[]
{
string.Format(Txt.Comunicaciones.ModificacionDenegadaPorCategoria, modificar.Categoria.Nombre)
}
};
}
}
else
{
result = new
{
Errors = new[]
{
string.Format(Txt.ErroresComunes.NoExiste, Txt.Comunicaciones.ArtEntidad).Frase()
}
};
}
}
else
{
var nuevo = srv.Create();
model.ActualizarEntidad(nuevo, mantenerUbicacion);
nuevo.UsuarioID = CurrentUserID();
nuevo.Instantanea = model.FechaPublicacion < DateTime.Now;
srv.Insert(nuevo);
await srv.ApplyChangesAsync();
result = ComunicacionGrid.FromEntity(nuevo, CategoriasPermitidasIds, PeriodoEnvioPushHoras);
if (nuevo.Instantanea)
{
if (EnviarPush(nuevo))
{
nuevo.PushEnviada = true;
nuevo.PushFecha = DateTime.Now;
await srv.ApplyChangesAsync();
}
else
{
nuevo.Instantanea = false;
await srv.ApplyChangesAsync();
}
}
}
}
else
{
log.Warn($"El usuario {Usuario.Nombre} ({Usuario.UsuarioID}) ha intentado crear o modificar una comunicación estableciendo la categoría {model.CategoriaID} que no tiene asignada.");
result = new { Errors = new[] { Txt.Comunicaciones.CategoriaNoPermitida } };
}
}
else
{
// TODO: Serializar a result.Errors los errores del modelo.
result = new { Errors = new[] { "Los datos de la comunicación no son válidos. " } };
}
}
catch (Exception e)
{
string accion = model.ComunicacionID != 0 ? "modificar" : "añadir";
log.Error($"Error al {accion} la comunicación.", e);
result = new { Errors = new[] { string.Format(Txt.ErroresComunes.Aniadir, Txt.Comunicaciones.ArtEntidad).Frase() } };
}
return(Json(result));
}
public async Task <ActionResult> Modificar([DataSourceRequest] DataSourceRequest request, ComunicacionGrid model)
{
DataSourceResult result = new[] { model }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
// Validar la categoría escogida por el usuario
if (CategoriaPermitida(model.CategoriaID))
{
try
{
IAplicacionesServicio appSrv = Servicios.AplicacionesServicio();
Aplicacion app = appSrv.GetSingle(c => c.AplicacionID == Aplicacion.AplicacionID);
bool mantenerUbicacion = app.Caracteristicas.Any(c => c.Nombre == "GeoPosicionamiento");
var srv = Servicios.ComunicacionesServicio();
var modificar = srv.GetSingle(p => p.ComunicacionID == model.ComunicacionID);
if (modificar != null)
{
// Si el usuario que edita la comunicación no tiene limitadas las categorías o
// bien tiene asignada la que tenía la comunicación originalmente y es una
// categoría activa, se permite la modificación.
if (CategoriaPermitida(modificar.CategoriaID))
{
// Guardar en variables aparte los ids de adjunto e imagen, por si hay que
// eliminarlos.
long?documentoEliminar = null, imagenEliminar = null;
if (model.AdjuntoDocumentoID == null)
{
documentoEliminar = modificar.AdjuntoDocumentoID;
}
if (model.ImagenDocumentoID == null)
{
imagenEliminar = modificar.ImagenDocumentoID;
}
model.ActualizarEntidad(modificar, mantenerUbicacion);
await srv.ApplyChangesAsync();
result = new[]
{
ComunicacionGrid.FromEntity(modificar, CategoriasPermitidasIds, PeriodoEnvioPushHoras)
}.ToDataSourceResult(request, ModelState);
// La eliminación de documentos (registro de la tabla Documentos y fichero de
// disco) se realiza después de haber actualizado la comunicación (poner FK a
// null) para garantizar que la comunicación se actualiza aunque falle la
// la eliminación en disco. Si hubiera fallos, quedaría el registro de documento
// sin ninguna comunicación que lo enlace, así como el archivo en disco.
if (documentoEliminar.HasValue)
{
try
{
await FileManager.EliminarDocumento(documentoEliminar.Value);
}
catch (Exception e)
{
log.Error($"Error al eliminar documento {documentoEliminar.Value} durante la modificación de su comunicación asociada.", e);
}
}
if (imagenEliminar.HasValue)
{
try
{
await FileManager.EliminarDocumento(imagenEliminar.Value);
}
catch (Exception e)
{
log.Error($"Error al eliminar imagen {imagenEliminar.Value} durante la modificación de su comunicación asociada.", e);
}
}
}
else
{
result.Errors = new[] { string.Format(Txt.Comunicaciones.ModificacionDenegadaPorCategoria, modificar.Categoria.Nombre) };
}
}
else
{
result.Errors = new[] { string.Format(Txt.ErroresComunes.NoExiste, Txt.Comunicaciones.ArtEntidad).Frase() };
}
}
catch (Exception e)
{
log.Error("Error al modificar la comunicación con id=" + model.ComunicacionID, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar, Txt.Comunicaciones.ArtEntidad).Frase() };
}
}
else
{
log.Warn($"El usuario {Usuario.Nombre} ({Usuario.UsuarioID}) ha intentado modificar la comunicación {model.ComunicacionID} con la categoría {model.CategoriaID} que no tiene asignada.");
result.Errors = new[] { Txt.Comunicaciones.CategoriaNoPermitida };
}
}
return(Json(result));
}
public async Task <ActionResult> Modificar([DataSourceRequest] DataSourceRequest request,
UsuarioGrid usuario)
{
DataSourceResult result = new[] { usuario }.ToDataSourceResult(request, ModelState);
if (ModelState.IsValid)
{
bool usuarioActualizado = false;
try
{
IUsuariosServicio srv = Servicios.UsuariosServicio();
Usuario modificar = srv.GetSingle(u => u.UsuarioID == usuario.UsuarioID);
if (modificar != null)
{
if (usuario.Aplicaciones == null)
{
usuario.Aplicaciones = new long[0];
}
usuario.ActualizarEntidad(modificar);
IEnumerable <long> aplicacionesActuales = modificar.Aplicaciones.Select(cl => cl.AplicacionID);
IEnumerable <long> aplicacionesAniadirIDs = usuario.Aplicaciones.Where(cl => !aplicacionesActuales.Contains(cl));
IEnumerable <long> aplicacionesEliminar = aplicacionesActuales
.Where(e => !usuario.Aplicaciones.Contains(e)).ToArray();
foreach (var e in aplicacionesEliminar)
{
Aplicacion aEliminar = modificar.Aplicaciones
.Single(eID => eID.AplicacionID == e);
modificar.Aplicaciones.Remove(aEliminar);
}
// Añadir las aplicaciones que vengan en el array de ids de aplicaciones y que no
// tenga ya el usuario.
IAplicacionesServicio srvAplicacions = Servicios.AplicacionesServicio();
modificar.Aplicaciones
.AddRange(srvAplicacions.Get(cl => aplicacionesAniadirIDs.Contains(cl.AplicacionID)));
IdentityResult ir = await UserManager.UpdateAsync(modificar);
if (ir.Succeeded)
{
usuarioActualizado = true;
await UserManager.EstablecerRol(modificar, usuario.PerfilID);
result = new[] { UsuarioGrid.FromEntity(modificar) }.ToDataSourceResult(request, ModelState);
}
else
{
foreach (var error in ir.Errors)
{
ModelState.AddModelError("", error);
}
result = new[] { usuario }.ToDataSourceResult(request, ModelState);
}
}
else
{
result.Errors = new[] { string.Format(Txt.ErroresComunes.NoExiste, Txt.Usuarios.ArtEntidad).Frase() };
}
}
catch (Exception e)
{
if (usuarioActualizado)
{
log.Error($"Error al establecer perfiles del usuario creado {usuario.Email}", e);
result.Errors = new[] { string.Format(Txt.Usuarios.ErrorEstablecerPerfiles, usuario.Email).Frase() };
}
else
{
log.Error("Error al modificar el usuario con id=" + usuario.UsuarioID, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Modificar, Txt.Usuarios.ArtEntidad).Frase() };
}
}
}
return(Json(result));
}