public async Task <ActionResult> ActivarDesactivar(long comunicacionId)
{
try
{
var srv = Servicios.ComunicacionesServicio();
var modificar = await srv.GetSingleAsync(p => p.ComunicacionID == comunicacionId);
if (modificar != null)
{
// Validar la categoría escogida por el usuario
if (CategoriaPermitida(modificar.CategoriaID))
{
modificar.Activo = !modificar.Activo;
await srv.ApplyChangesAsync();
return(Json(true));
}
else
{
log.Warn($"Solicitada activación/desactivación de una comunicación de una categoría no autorizada al usuario. Usuario: {Usuario.ApellidosNombre}, Comunicación: {comunicacionId}, Categoría: {modificar.Categoria.Nombre}.");
return(Json(new { Error = Txt.Comunicaciones.CategoriaNoPermitida }));
}
}
else
{
log.Warn("Solicitada activación/desactivación de una comunicación inexistente o que no pertenece a la aplicación de trabajo.");
return(Json(new { Error = Util.Frase(string.Format(Txt.ErroresComunes.NoExiste, Txt.Comunicaciones.ArtEntidad)) }));
}
}
catch (Exception e)
{
log.Error($"Error al activar/desactivar la comunicación {comunicacionId}.", e);
return(Json(new { Error = string.Format(Txt.ErroresComunes.ActivarDesactivar, Txt.Comunicaciones.ArtEntidad) }));
}
}
/// <summary>
/// Devuelve la lista de publicaciones de la aplicación actual para la web, aplicando posibles
/// restricciones de filtrado, ordenación y paginado.
/// </summary>
/// <returns>DataSourceResult para un componente telerik tipo Grid, ListView o similar.</returns>
public async Task <ActionResult> ComunicacionesPublicadas([DataSourceRequest] DataSourceRequest request)
{
// Si el único filtro es CategoriaID == -1, tenemos que devolver sólo las comunicaciones destacadas
if (request.Filters.Count == 1)
{
FilterDescriptor filtro = request.Filters[0] as FilterDescriptor;
if (filtro != null &&
filtro.Member == "CategoriaID" &&
filtro.Operator == FilterOperator.IsEqualTo &&
filtro.Value.ToString() == "-1")
{
request.Filters.Clear();
request.Filters.Add(new FilterDescriptor("Destacado", FilterOperator.IsEqualTo, true));
}
}
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
IEnumerable <ComunicacionModel> comunicacionesPublicadas =
Aplicacion == null
? new List <ComunicacionModel>(0)
: (await srv.PublicadasAsync()).Select(ComunicacionModel.FromEntity);
return(Json(comunicacionesPublicadas.ToDataSourceResult(request),
JsonRequestBehavior.AllowGet));
}
public async Task <IHttpActionResult> Detalle(SolicitudComunicacionesModel model)
{
if (!ComprobarClaves(model))
{
return(Unauthorized());
}
// Validación del modelo: ComunicacionID tiene valor, UID se ha especificado, Subdominio se ha especificado.
if (!model.ComunicacionID.HasValue || string.IsNullOrWhiteSpace(model.UID) || string.IsNullOrWhiteSpace(model.Subdominio))
{
log.Warn($"Modelo no válido: ComunicacionID={model.ComunicacionID}, UID={model.UID}, subdominio={model.Subdominio}.");
return(BadRequest());
}
ComunicacionDetalleModel resul;
try
{
Aplicacion app = Aplicacion(model.Subdominio);
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion c = srv.ConsultarComunicacion(model.ComunicacionID.Value, model.UID, GetClientIp());
await srv.ApplyChangesAsync();
resul = ComunicacionDetalleModel.FromEntity(c);
return(Ok(resul));
}
catch (Exception e)
{
log.Error($"Error al consultar comunicación {model.ComunicacionID} el terminal {model.UID}.", e);
return(Ok <ComunicacionDetalleModel>(null));
}
}
public ActionResult Miniatura(long id)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion comunicacion = srv.GetSingle(c => c.ComunicacionID == id);
if (comunicacion != null)
{
if (comunicacion.Imagen == null)
{
return(File("~/Content/Images/Blanco.png", contentType: "image/png"));
}
else
{
var cd = new ContentDisposition
{
FileName = Path.GetFileNameWithoutExtension(comunicacion.Imagen.Nombre) + "_thumb"
+ Path.GetExtension(comunicacion.Imagen.Nombre),
Inline = false,
};
Response.AppendHeader(name: "Content-Disposition", value: cd.ToString());
FileStream str = FileManager.ObtenerMiniatura(comunicacion.Imagen);
return(new FileStreamResult(str, comunicacion.Imagen.Mime));
}
}
else
{
return(HttpNotFound());
}
}
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));
}
/// <summary>
/// Devuelve una comunicación de la aplicación actual dado su ID.
/// </summary>
/// <param name="comunicacionID">ID de la comunicación solicitada.</param>
public async Task <ActionResult> ComunicacionDetalle(long comunicacionID)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion c = srv.ConsultarComunicacion(comunicacionID, $"{Request.UserHostName}-{Request.Browser.Browser}", Request.UserHostAddress);
await srv.ApplyChangesAsync();
ComunicacionDetalleModel resul = ComunicacionDetalleModel.FromEntity(c);
return(Json(resul, JsonRequestBehavior.AllowGet));
}
public ActionResult ListaComunicaciones()
{
var srv = Servicios.ComunicacionesServicio();
var consulta = srv.Get();
var registros = consulta.Select(l => ComunicacionGrid.FromEntity(l, CategoriasPermitidasIds, PeriodoEnvioPushHoras));
// Creamos el modelo de lista de selección a partir del resultado obtenido de la
// consulta. Si se ha especificado un país, los grupos se establecen por
// Pais/Provincia. Si no, sólo por Provincia.
var lista = new SelectList(registros, "ComunicacionID", "Nombre");
return(Json(lista, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> LeerUnoDetalle(long comunicacionID)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion com = await srv.GetSingleAsync(c => c.ComunicacionID == comunicacionID);
if (com != null)
{
return(Json(ComunicacionDetalleModel.FromEntity(com), JsonRequestBehavior.AllowGet));
}
else
{
return(HttpNotFound());
}
}
public ActionResult ComunicacionesPublicadas([DataSourceRequest] DataSourceRequest request)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
IEnumerable <Comunicacion> comunicacionesPublicadas1 = srv.Publicadas().ToList();
List <ComunicacionGrid> comunicacionesPublicadas = new List <ComunicacionGrid>();
foreach (var c in comunicacionesPublicadas1)
{
comunicacionesPublicadas.Add(ComunicacionGrid.FromEntity(c, CategoriasPermitidasIds, PeriodoEnvioPushHoras));
}
return(Json(comunicacionesPublicadas.ToDataSourceResult(request),
JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> LeerUno(long comunicacionID)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion com = await srv.GetSingleAsync(c => c.ComunicacionID == comunicacionID);
if (com != null)
{
return(Json(ComunicacionGrid.FromEntity(com, CategoriasPermitidasIds, PeriodoEnvioPushHoras),
JsonRequestBehavior.AllowGet));
}
else
{
return(HttpNotFound());
}
}
public ActionResult UltimasComunicaciones()
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
IEnumerable <Comunicacion> ultimas1 = srv
.Get(c => !c.Borrado, cc => cc.OrderByDescending(c => c.FechaCreacion),
includeProperties: "Categoria, Adjunto, Accesos"
)
.Take(10);
List <ComunicacionGrid> ultimas = new List <ComunicacionGrid>();
var categoriasPermitidas = Aplicacion.Categorias.Select(c => c.CategoriaID);
foreach (var c in ultimas1)
{
ultimas.Add(ComunicacionGrid.FromEntity(c, categoriasPermitidas, PeriodoEnvioPushHoras));
}
return(Json(ultimas, JsonRequestBehavior.AllowGet));
}
public ActionResult Estadisticas()
{
EstadisticasModel resul = new EstadisticasModel();
ITerminalesServicio trmSrv = Servicios.TerminalesServicio();
resul.Terminales = trmSrv.Get().Count();
IComunicacionesServicio comSrv = Servicios.ComunicacionesServicio();
resul.Comunicaciones = comSrv.Get().Count();
IComunicacionesAccesosServicio accSrv = Servicios.ComunicacionesAccesosServicio();
DateTime haceUnMes = DateTime.Now.AddMonths(-1);
resul.VisualizacionesUltimoMes = accSrv.Get(acc => acc.Fecha >= haceUnMes).Count();
resul.Visualizaciones = accSrv.Get().Count();
return(Json(resul, JsonRequestBehavior.AllowGet));
}
public ActionResult Documento(long id, bool descargar = false)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
Comunicacion comunicacion = srv.GetSingle(c => c.ComunicacionID == id);
if (comunicacion == null || comunicacion.Adjunto == null)
{
return(HttpNotFound());
}
var cd = new ContentDisposition
{
FileName = comunicacion.Adjunto.Nombre,
Inline = !descargar,
};
Response.AppendHeader(name: "Content-Disposition", value: cd.ToString());
Response.AppendHeader(name: "Content-Length", value: comunicacion.Adjunto.Tamano.ToString());
FileStream str = FileManager.ObtenerDocumento(comunicacion.Adjunto);
return(new FileStreamResult(str, comunicacion.Adjunto.Mime));
}
public async Task <ActionResult> Leer([DataSourceRequest] DataSourceRequest request)
{
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
List <ComunicacionGrid> registros = new List <ComunicacionGrid>();
var query = (await srv.GetAsync(c => !c.Borrado, includeProperties: "Categoria, Adjunto, Accesos"));
if (User.Identity.IsAuthenticated)
{
foreach (var c in query)
{
registros.Add(ComunicacionGrid.FromEntityParaAdmin(c, CategoriasPermitidasIds, PeriodoEnvioPushHoras));
}
}
else
{
foreach (var c in query)
{
registros.Add(ComunicacionGrid.FromEntity(c, CategoriasPermitidasIds, PeriodoEnvioPushHoras));
}
}
return(Json(registros.ToDataSourceResult(request), JsonRequestBehavior.AllowGet));
}
public ActionResult Index(long?id = null)
{
if (id.HasValue)
{
var comSrv = Servicios.ComunicacionesServicio();
Comunicacion com = comSrv.GetSingle(c => c.ComunicacionID == id.Value);
ViewBag.Comunicacion = ComunicacionDetalleModel.FromEntity(com);
}
var srv = Servicios.CategoriasServicio();
var registros = srv.ListaCategorias()
.Select(CategoriaModel.FromEntity)
.ToList();
registros.Insert(0,
new CategoriaModel
{
CategoriaID = 0,
Nombre = Txt.Comunicaciones.TodasLasComunicaciones,
Orden = -1,
Activo = true,
Icono = "fa-asterisk"
});
registros.Insert(1,
new CategoriaModel
{
CategoriaID = -1,
Nombre = Txt.Comunicaciones.Destacados,
Orden = 0,
Activo = true,
Icono = "fa-star"
});
ViewBag.Categorias = registros;
return(View());
}
public async Task <IHttpActionResult> Lista(SolicitudComunicacionesModel model)
{
// Validación del modelo: Subdominio se ha especificado.
if (string.IsNullOrWhiteSpace(model.Subdominio))
{
return(BadRequest("Subdominio no válido"));
}
if (!ComprobarClaves(model))
{
return(Unauthorized());
}
IComunicacionesServicio srv = Servicios.ComunicacionesServicio();
// Si categoriaID es -1, nos están pidiendo las publicaciones destacadas, sin filtrar por
// categoría.
IEnumerable <Comunicacion> comunicaciones = model.CategoriaID == -1
? await srv.PublicadasAsync(categoriaID : null, soloDestacadas : true, timestamp : model.TimeStamp)
: await srv.PublicadasAsync(categoriaID : model.CategoriaID, timestamp : model.TimeStamp);
return(Ok(comunicaciones
.Select(ComunicacionDetalleModel.FromEntity)
.AsQueryable()));
}
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> Eliminar([DataSourceRequest] DataSourceRequest request, ComunicacionGrid model)
{
DataSourceResult result = new[] { model }.ToDataSourceResult(request, ModelState);
try
{
var srv = Servicios.ComunicacionesServicio();
var eliminar = srv.GetSingle(p => p.ComunicacionID == model.ComunicacionID);
if (eliminar != null)
{
long?documentoEliminar = null, imagenEliminar = null;
if (model.AdjuntoDocumentoID != null)
{
documentoEliminar = eliminar.AdjuntoDocumentoID;
}
if (model.ImagenDocumentoID != null)
{
imagenEliminar = eliminar.ImagenDocumentoID;
}
srv.Delete(eliminar);
await srv.ApplyChangesAsync();
// La eliminación de documentos (registro de la tabla Documentos y fichero de disco) se
// realiza después de haber persistido la eliminación de la comunicación para garantizar
// que la comunicación se elimina aunque falle la eliminación de ficheros en disco. Si
// hubiera fallos de disco, 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 eliminació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 eliminación de su comunicación asociada.", e);
}
}
}
else
{
log.Debug("Eliminar parámetro: el parámetro con id=" + model.ComunicacionID + " no existe.");
result.Errors = new[] { string.Format(Txt.ErroresComunes.NoExiste, Txt.Comunicaciones.ArtEntidad).Frase() };
}
}
catch (Exception e)
{
log.Error("Error al eliminar el parámetro con id=" + model.ComunicacionID, e);
result.Errors = new[] { string.Format(Txt.ErroresComunes.Eliminar, Txt.Comunicaciones.ArtEntidad).Frase() };
}
return(Json(result));
}