public override async Task OnConnectedAsync()
{
try
{
await base.OnConnectedAsync();
var p = await context.Propietarios.FirstAsync(x => x.Email == Context.UserIdentifier);
var otros = await context.Conectados.Where(x => x.Usuario != Context.UserIdentifier).ToListAsync();
var conectado = new Conectado(p);
var yaConectado = await context.Conectados.FindAsync(Context.UserIdentifier);
if (yaConectado == null)
{
await context.Conectados.AddAsync(conectado);
await context.SaveChangesAsync();
}
await Clients.All.UsuarioConectado(conectado);
foreach (var c in otros)
{
//notificar los demás conectados al reciente
await Clients.Caller.UsuarioConectado(c);
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <ActionResult <Muro> > DeleteMuro(int id)
{
// Se valida que el usuario es el dueño del muro a eliminar...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == id &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(id),
"El muro ingresado no existe o no eres dueño de éste.");
return(ValidationProblem());
}
// Se elimina el muro seleccionado...
Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == id);
if (muro != null)
{
_context.Muro.Remove(muro);
await _context.SaveChangesAsync();
}
return(Ok());
}
public void Start()
{
bool started = watcher.TryStart(false, TimeSpan.FromMilliseconds(2000));
if (started)
{
Conectado?.Invoke(this, new EventArgs());
}
}
public async Task <ActionResult <SalPermisoLista> > PutUsuarioMuro(EntPermisoRelacion permisoRelacion)
{
permisoRelacion.Correo = permisoRelacion.Correo.Trim();
// Se valida que el muro pertenezca al usuario que inició sesión...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == permisoRelacion.IdMuro &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(permisoRelacion.IdMuro),
"El muro ingresado no existe, o no te pertenece.");
return(ValidationProblem());
}
// Se valida que exista la relación que se está tratando de modificar...
usuarioMuro = await _context.UsuarioMuro
.Include(um => um.IdDuennoNavigation)
.SingleOrDefaultAsync(um =>
um.IdDuennoNavigation.Correo == permisoRelacion.Correo &&
um.IdMuro == permisoRelacion.IdMuro &&
um.Permiso != 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(permisoRelacion.Correo),
"El permiso que se quiere modificar no existe.");
return(ValidationProblem());
}
// Se cambia el permiso de la relación...
usuarioMuro.Permiso = permisoRelacion.Permiso;
await _context.SaveChangesAsync();
SalPermisoLista salida = new SalPermisoLista()
{
IdUsuario = usuarioMuro.IdDuenno,
NombreUsuario = usuarioMuro.IdDuennoNavigation.Nombre,
CorreoUsuario = usuarioMuro.IdDuennoNavigation.Correo,
Permiso = usuarioMuro.Permiso
};
return(salida);
}
public async Task <ActionResult <SalMuroConEtapas> > GetMuro(int idMuro)
{
// Se valida que el usuario sea dueño del muro...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.Include(um => um.IdMuroNavigation)
.SingleOrDefaultAsync(um =>
um.IdMuro == idMuro &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(idMuro),
"El muro ingresado no existe o no eres dueño de éste.");
return(ValidationProblem());
}
// Se crea la salida solicitada...
SalMuroConEtapas salida = new SalMuroConEtapas()
{
IdMuro = usuarioMuro.IdMuroNavigation.Id,
NombreMuro = usuarioMuro.IdMuroNavigation.Nombre,
FechaCreacion = usuarioMuro.IdMuroNavigation.FechaCreacion.ToString("yyyyMMddHHmmss"),
FechaUltimaModificacion = usuarioMuro.IdMuroNavigation.FechaUltimaModificacion.ToString("yyyyMMddHHmmss"),
Permiso = usuarioMuro.Permiso
};
// Se obtiene una lista de las etapas asociadas al muro...
ICollection <Etapa> etapas = await _context.Etapa
.Where(e => e.IdMuro == idMuro)
.OrderBy(e => e.Posicion)
.ToListAsync();
// Se agregan las etapas a la salida...
foreach (Etapa etapa in etapas)
{
SalEtapaBase etapaBase = new SalEtapaBase()
{
Id = etapa.Id,
Nombre = etapa.Nombre,
Posicion = etapa.Posicion
};
salida.Etapas.Add(etapaBase);
}
return(salida);
}
public async Task <ActionResult <SalObtenerDatosUsuario> > GetUsuario()
{
Usuario usuario = await _context.Usuario
.SingleOrDefaultAsync(u => u.Id == Conectado.ID(this));
SalObtenerDatosUsuario salida = new SalObtenerDatosUsuario();
if (usuario != null)
{
salida.nombre = usuario.Nombre;
salida.correo = usuario.Correo;
}
return(salida);
}
public async Task <IActionResult> DeleteUsuarioMuro(int idMuro, string correo)
{
correo = correo.Trim();
// Se valida que el muro pertenezca al usuario que inició sesión...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == idMuro &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(idMuro),
"El muro ingresado no existe, o no te pertenece.");
return(ValidationProblem());
}
// Se valida que exista la relación que se está tratando de eliminar...
usuarioMuro = await _context.UsuarioMuro
.Include(um => um.IdDuennoNavigation)
.SingleOrDefaultAsync(um =>
um.IdDuennoNavigation.Correo == correo &&
um.IdMuro == idMuro &&
um.Permiso != 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(correo),
"El permiso que se quiere eliminar no existe.");
return(ValidationProblem());
}
// Se elimina la relación...
_context.UsuarioMuro.Remove(usuarioMuro);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <IEnumerable <SalMuroDuenno> > > GetMuro()
{
List <SalMuroDuenno> salida = new List <SalMuroDuenno>();
// Se obtiene la lista de muros visibles por el usuario...
List <UsuarioMuro> muros = await _context.UsuarioMuro
.Include(um => um.IdMuroNavigation)
.Where(um => um.IdDuenno == Conectado.ID(this))
.ToListAsync();
// Por cada muro obtenido, se obtienen los datos de éste...
foreach (UsuarioMuro usuarioMuro in muros)
{
SalMuroDuenno muroLista = new SalMuroDuenno()
{
IdMuro = usuarioMuro.IdMuro,
NombreMuro = usuarioMuro.IdMuroNavigation.Nombre,
Permiso = usuarioMuro.Permiso,
FechaCreacion = usuarioMuro.IdMuroNavigation.FechaCreacion.ToString("dd/MM/yyyy HH:mm:ss"),
FechaUltimaModificacion = usuarioMuro.IdMuroNavigation.FechaUltimaModificacion.ToString("dd/MM/yyyy HH:mm:ss")
};
// Se obtiene el nombre/correo del dueño del muro visible por el usuario...
UsuarioMuro duennoMuro = await _context.UsuarioMuro
.Include(um => um.IdDuennoNavigation)
.Where(um =>
um.Permiso == 1 &&
um.IdMuro == usuarioMuro.IdMuro)
.FirstOrDefaultAsync();
if (duennoMuro != null)
{
muroLista.NombreDuenno = duennoMuro.IdDuennoNavigation.Nombre;
muroLista.CorreoDuenno = duennoMuro.IdDuennoNavigation.Correo;
}
salida.Add(muroLista);
}
return(salida);
}
public async Task <ActionResult <IEnumerable <SalPermisoLista> > > GetUsuarioMuro(int idMuro)
{
List <SalPermisoLista> salida = new List <SalPermisoLista>();
// Se valida que el usuario es el dueño del muro...
UsuarioMuro duennoMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == idMuro &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1);
if (duennoMuro == null)
{
ModelState.AddModelError(
nameof(idMuro),
"El muro ingresado no existe o no eres dueño de éste.");
return(ValidationProblem());
}
// Se obtiene los usuarios que tienen permisos sobre el muro...
List <UsuarioMuro> usuariosMuro = await _context.UsuarioMuro
.Include(um => um.IdDuennoNavigation)
.Where(um => um.IdMuro == idMuro)
.ToListAsync();
// Se agregan los elementos a la salida...
foreach (UsuarioMuro usuarioMuro in usuariosMuro)
{
SalPermisoLista permiso = new SalPermisoLista()
{
IdUsuario = usuarioMuro.IdDuenno,
NombreUsuario = usuarioMuro.IdDuennoNavigation.Nombre,
CorreoUsuario = usuarioMuro.IdDuennoNavigation.Correo,
Permiso = usuarioMuro.Permiso
};
salida.Add(permiso);
}
return(salida);
}
public async Task <IActionResult> Renunciar(int idMuro)
{
// Se valida que exista la relación, y el usuario no sea dueño...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdDuenno == Conectado.ID(this) &&
um.IdMuro == idMuro &&
um.Permiso != 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(idMuro),
"No tienes permisos sobre el muro seleccionado.");
return(ValidationProblem());
}
// Se elimina el permiso del usuario...
_context.UsuarioMuro.Remove(usuarioMuro);
await _context.SaveChangesAsync();
return(Ok());
}
private void DevicesDeviceDetected(object sender, DeviceEventArgs e)
{
nmeaInterpreter.Start(e.Device);
Conectado?.Invoke(this, new EventArgs());
}
public async Task <IActionResult> PutMuro(EntMuroIdEtapaId entradaMuro)
{
//Se valida que el usuario es el dueño del muro a modificar...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro.SingleOrDefaultAsync(um =>
um.IdDuenno == Conectado.ID(this) &&
um.IdMuro == entradaMuro.Id &&
um.Permiso == 1);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(entradaMuro.Id),
"El muro ingresado no existe o no eres dueño de éste.");
return(ValidationProblem());
}
Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == entradaMuro.Id);
if (muro == null)
{
ModelState.AddModelError(
nameof(entradaMuro.Id),
"El muro ingresado no existe o no eres dueño de éste.");
return(ValidationProblem());
}
muro.Nombre = entradaMuro.Nombre;
muro.FechaUltimaModificacion = DateTime.Now;
// Se modifican las etapas existentes, y se marcan las etapas a eliminar...
List <Etapa> etapasEliminadas = new List <Etapa>();
List <Etapa> etapas = await _context.Etapa
.Where(e => e.IdMuro == muro.Id)
.OrderBy(e => e.Posicion)
.ToListAsync();
foreach (Etapa etapa in etapas)
{
bool clienteLoElimino = true;
foreach (EntEtapaId etapaCliente in entradaMuro.Etapas)
{
if (etapa.Id == etapaCliente.Id)
{
etapa.Nombre = etapaCliente.Nombre;
etapa.Posicion = etapaCliente.Posicion;
clienteLoElimino = false;
break;
}
}
if (clienteLoElimino)
{
etapasEliminadas.Add(etapa);
}
}
// Se agregan las etapas nuevas al muro...
foreach (EntEtapaId etapaCliente in entradaMuro.Etapas)
{
if (etapaCliente.Id == 0)
{
Etapa etapa = new Etapa()
{
IdMuro = muro.Id,
Nombre = etapaCliente.Nombre,
Posicion = etapaCliente.Posicion
};
await _context.Etapa.AddAsync(etapa);
}
}
await _context.SaveChangesAsync();
// Se cambian las tareas de etapas eliminadas, a las etapas que corresponden...
if (entradaMuro.Accion != 3)
{
Etapa etapaDestino = null;
if (entradaMuro.Accion == 1)
{
etapas = await _context.Etapa
.Where(e => e.IdMuro == muro.Id)
.OrderBy(e => e.Posicion)
.ToListAsync();
}
else
{
etapas = await _context.Etapa
.Where(e => e.IdMuro == muro.Id)
.OrderByDescending(e => e.Posicion)
.ToListAsync();
}
foreach (Etapa etapa in etapas)
{
bool seraEliminada = false;
foreach (Etapa etapaEliminada in etapasEliminadas)
{
if (etapa.Id == etapaEliminada.Id)
{
seraEliminada = true;
break;
}
}
if (!seraEliminada)
{
etapaDestino = etapa;
break;
}
}
if (etapaDestino != null)
{
Tarea ultTarea = await _context.Tarea
.Where(t => t.IdEtapa == etapaDestino.Id)
.OrderByDescending(t => t.Posicion)
.FirstOrDefaultAsync();
List <Tarea> tareasMover = new List <Tarea>();
foreach (Etapa etapaEliminada in etapasEliminadas)
{
tareasMover.AddRange(await _context.Tarea
.Where(t => t.IdEtapa == etapaEliminada.Id)
.OrderBy(t => t.Posicion)
.ToListAsync());
}
short pos = 0;
if (ultTarea != null)
{
pos = ultTarea.Posicion;
}
foreach (Tarea tareaMover in tareasMover)
{
pos++;
tareaMover.IdEtapa = etapaDestino.Id;
tareaMover.Posicion = pos;
}
await _context.SaveChangesAsync();
}
}
_context.Etapa.RemoveRange(etapasEliminadas);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <SalMuroConEtapas> > PostMuros(EntMuroEtapa entradaMuro)
{
// Se crea el nuevo muro...
Muro muro = new Muro()
{
Nombre = entradaMuro.Nombre,
FechaCreacion = DateTime.Now,
FechaUltimaModificacion = DateTime.Now
};
await _context.Muro.AddAsync(muro);
await _context.SaveChangesAsync();
// Se crea la relación usuario/muro...
UsuarioMuro usuarioMuro = new UsuarioMuro()
{
IdDuenno = Conectado.ID(this),
IdMuro = muro.Id,
Permiso = 1
};
await _context.UsuarioMuro.AddAsync(usuarioMuro);
// Se crean las etapas del muro...
List <Etapa> etapasCreadas = new List <Etapa>();
foreach (EntEtapaBase entEtapa in entradaMuro.Etapas)
{
Etapa etapa = new Etapa()
{
IdMuro = muro.Id,
Nombre = entEtapa.Nombre,
Posicion = entEtapa.Posicion
};
await _context.Etapa.AddAsync(etapa);
etapasCreadas.Add(etapa);
}
await _context.SaveChangesAsync();
SalMuroConEtapas salida = new SalMuroConEtapas()
{
IdMuro = muro.Id,
NombreMuro = muro.Nombre,
FechaCreacion = muro.FechaCreacion.ToString("yyyyMMddHHmmss"),
FechaUltimaModificacion = muro.FechaUltimaModificacion.ToString("yyyyMMddHHmmss"),
Permiso = usuarioMuro.Permiso
};
foreach (Etapa etapaCreada in etapasCreadas)
{
SalEtapaBase salidaEtapa = new SalEtapaBase()
{
Id = etapaCreada.Id,
Nombre = etapaCreada.Nombre,
Posicion = etapaCreada.Posicion
};
salida.Etapas.Add(salidaEtapa);
}
return(salida);
}
public async Task <ActionResult <SalMuroConTareas> > ModificarTareas(EntMuroSoloId entradaMuro)
{
// Se valida que el usuario tenga permisos de edición en el muro...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.Include(um => um.IdMuroNavigation)
.SingleOrDefaultAsync(um =>
um.IdMuro == entradaMuro.Id &&
um.IdDuenno == Conectado.ID(this) &&
(um.Permiso == 1 ||
um.Permiso == 2)
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(entradaMuro.Id),
"El muro ingresado no existe o no tienes permisos sobre éste.");
return(ValidationProblem());
}
// Se valida que todas las etapas sean parte del muro a editar...
foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
{
Etapa etapa = await _context.Etapa
.SingleOrDefaultAsync(e =>
e.Id == entradaEtapa.Id &&
e.IdMuro == entradaMuro.Id
);
if (etapa == null)
{
ModelState.AddModelError(
nameof(entradaEtapa.Id),
"Una de las etapas ingresadas no pertenece al muro...");
return(ValidationProblem());
}
}
// Se eliminan las tareas que no son recibidas desde el cliente...
List <Tarea> tareasExistentes = await _context.Tarea
.Include(t => t.IdEtapaNavigation)
.Where(t => t.IdEtapaNavigation.IdMuro == entradaMuro.Id)
.ToListAsync();
foreach (Tarea tareaExistente in tareasExistentes)
{
bool existeTarea = false;
foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
{
foreach (EntTareaBase entradaTarea in entradaEtapa.Tareas)
{
if (tareaExistente.Id == entradaTarea.Id)
{
existeTarea = true;
break;
}
}
if (existeTarea)
{
break;
}
;
}
if (!existeTarea)
{
_context.Tarea.Remove(tareaExistente);
}
}
// Se agregan o modifican el resto de tareas...
foreach (EntEtapaSoloId entradaEtapa in entradaMuro.Etapas)
{
foreach (EntTareaBase entradaTarea in entradaEtapa.Tareas)
{
Tarea tareaOriginal = await _context.Tarea
.Include(t => t.IdEtapaNavigation)
.SingleOrDefaultAsync(t =>
t.Id == entradaTarea.Id &&
t.IdEtapaNavigation.IdMuro == entradaMuro.Id
);
if (tareaOriginal == null)
{
// Se agregan las tareas que no existen en la base de datos...
Tarea nuevaTarea = new Tarea()
{
Titulo = entradaTarea.Titulo,
Descripcion = entradaTarea.Descripcion,
IdEtapa = entradaEtapa.Id,
Posicion = entradaTarea.Posicion,
Familia = entradaTarea.Familia,
Red = entradaTarea.Red,
Green = entradaTarea.Green,
Blue = entradaTarea.Blue
};
_context.Tarea.Add(nuevaTarea);
}
else
{
tareaOriginal.Titulo = entradaTarea.Titulo;
tareaOriginal.Descripcion = entradaTarea.Descripcion;
tareaOriginal.IdEtapa = entradaEtapa.Id;
tareaOriginal.Posicion = entradaTarea.Posicion;
tareaOriginal.Familia = entradaTarea.Familia;
tareaOriginal.Red = entradaTarea.Red;
tareaOriginal.Green = entradaTarea.Green;
tareaOriginal.Blue = entradaTarea.Blue;
_context.Tarea.Update(tareaOriginal);
}
}
}
// Se modifica la fecha de última actualización...
Muro muro = await _context.Muro.SingleOrDefaultAsync(m => m.Id == entradaMuro.Id);
muro.FechaUltimaModificacion = DateTime.Now;
await _context.SaveChangesAsync();
return(await ObtenerTareas(entradaMuro.Id));
}
public async Task <ActionResult <SalMuroConTareas> > ObtenerTareas(int idMuro)
{
// Se valida que el usuario tenga permisos sobre el muro...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.Include(um => um.IdMuroNavigation)
.SingleOrDefaultAsync(um =>
um.IdMuro == idMuro &&
um.IdDuenno == Conectado.ID(this) &&
(um.Permiso == 1 ||
um.Permiso == 2 ||
um.Permiso == 3)
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(idMuro),
"El muro ingresado no existe o no tienes permisos sobre éste.");
return(ValidationProblem());
}
// Se crea la salida solicitada...
SalMuroConTareas salida = new SalMuroConTareas()
{
IdMuro = usuarioMuro.IdMuroNavigation.Id,
NombreMuro = usuarioMuro.IdMuroNavigation.Nombre,
FechaCreacion = usuarioMuro.IdMuroNavigation.FechaCreacion.ToString("yyyyMMddHHmmss"),
FechaUltimaModificacion = usuarioMuro.IdMuroNavigation.FechaUltimaModificacion.ToString("yyyyMMddHHmmss"),
Permiso = usuarioMuro.Permiso
};
// Se obtiene una lista de las etapas asociadas al muro...
ICollection <Etapa> etapas = await _context.Etapa
.Where(e => e.IdMuro == idMuro)
.OrderBy(e => e.Posicion)
.ToListAsync();
// Se agregan las etapas a la salida...
foreach (Etapa etapa in etapas)
{
SalEtapaConTareas etapaConTareas = new SalEtapaConTareas()
{
Id = etapa.Id,
Nombre = etapa.Nombre,
Posicion = etapa.Posicion
};
// Se obtiene una lista de las tareas asociadas a la etapa...
ICollection <Tarea> tareas = await _context.Tarea
.Where(t => t.IdEtapa == etapa.Id)
.OrderBy(t => t.Posicion)
.ToListAsync();
// Se agregan las tareas a la etapa...
foreach (Tarea tarea in tareas)
{
SalTareaBase tareaBase = new SalTareaBase()
{
Id = tarea.Id,
Titulo = tarea.Titulo,
Descripcion = tarea.Descripcion,
Posicion = tarea.Posicion,
Familia = tarea.Familia,
Red = tarea.Red,
Green = tarea.Green,
Blue = tarea.Blue
};
etapaConTareas.Tareas.Add(tareaBase);
}
salida.Etapas.Add(etapaConTareas);
}
return(salida);
}
public async Task <IActionResult> PutUsuario(EntUsuarioModificacion entrada)
{
// Se obtiene el usuario del cliente conectado...
Usuario usuario = await _context.Usuario
.SingleOrDefaultAsync(u =>
u.Id == Conectado.ID(this));
if (entrada.ContrasennaActual != null && entrada.ContrasennaNueva != null)
{
// Si ingresó la contraseña actual y la contraseña nueva...
// Se valida el largo de la contraseña nueva...
if (entrada.ContrasennaNueva.Length < 8)
{
ModelState.AddModelError(
nameof(EntUsuarioModificacion.ContrasennaNueva),
"La nueva contraseña requiere tener 8 caracteres como mínimo.");
return(ValidationProblem());
}
// Se valida que la contraseña actual sea correcta...
var hasher = new PasswordHasher <Usuario>();
var result = hasher.VerifyHashedPassword(usuario, usuario.HashContrasenna, entrada.ContrasennaActual);
if (result != PasswordVerificationResult.Success)
{
ModelState.AddModelError(
nameof(EntUsuarioModificacion.ContrasennaActual),
"La contraseña actual ingresada no es correcta.");
return(ValidationProblem());
}
// Se genera el hash de la nueva contraseña...
usuario.HashContrasenna = hasher.HashPassword(usuario, entrada.ContrasennaNueva);
}
else
{
if (entrada.ContrasennaActual != null ^ entrada.ContrasennaNueva != null)
{
// Si solo ingreso la contraseña actual o la contraseña nueva...
if (entrada.ContrasennaActual == null)
{
ModelState.AddModelError(
nameof(EntUsuarioModificacion.ContrasennaActual),
"Para actualizar tu contraseña, debes ingresar tu contraseña actual.");
return(ValidationProblem());
}
else
{
ModelState.AddModelError(
nameof(EntUsuarioModificacion.ContrasennaNueva),
"Para actualizar tu contraseña, debes ingresar tu nueva contraseña.");
return(ValidationProblem());
}
}
}
// Se modifica el nombre del usuario...
usuario.Nombre = entrada.Nombre.Trim();
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <SalPermisoLista> > PostUsuarioMuro(EntPermisoRelacion permisoRelacion)
{
permisoRelacion.Correo = permisoRelacion.Correo.Trim();
// Se valida que el muro pertenezca al usuario que inició sesión...
UsuarioMuro usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == permisoRelacion.IdMuro &&
um.IdDuenno == Conectado.ID(this) &&
um.Permiso == 1
);
if (usuarioMuro == null)
{
ModelState.AddModelError(
nameof(permisoRelacion.IdMuro),
"El muro ingresado no existe, o no te pertenece.");
return(ValidationProblem());
}
// Se valida que el correo ingresado este registrado, y no sea el mismo del usuario que inició sesión...
Usuario usuario = await _context.Usuario.SingleOrDefaultAsync(u =>
u.Correo == permisoRelacion.Correo &&
u.Id != Conectado.ID(this));
if (usuario == null)
{
ModelState.AddModelError(
nameof(permisoRelacion.Correo),
"El correo ingresado no es válido.");
return(ValidationProblem());
}
// Se valida que la relación Muro/Usuario no existiese de antes...
usuarioMuro = await _context.UsuarioMuro
.SingleOrDefaultAsync(um =>
um.IdMuro == permisoRelacion.IdMuro &&
um.IdDuenno == usuario.Id
);
if (usuarioMuro != null)
{
ModelState.AddModelError(
nameof(permisoRelacion.Correo),
"El usuario ingresado ya tiene permisos sobre el muro.");
return(ValidationProblem());
}
// Se crea la nueva relación...
usuarioMuro = new UsuarioMuro {
IdDuenno = usuario.Id,
IdMuro = permisoRelacion.IdMuro,
Permiso = permisoRelacion.Permiso
};
await _context.UsuarioMuro.AddAsync(usuarioMuro);
await _context.SaveChangesAsync();
SalPermisoLista salida = new SalPermisoLista()
{
IdUsuario = usuarioMuro.IdDuenno,
NombreUsuario = usuario.Nombre,
CorreoUsuario = usuario.Correo,
Permiso = usuarioMuro.Permiso
};
return(salida);
}
