示例#1
0
        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));
        }
示例#2
0
        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));
        }
示例#3
0
        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));
        }