public async Task <IActionResult> PutTbInventario(int id, TbInventario tbInventario)
{
if (id != tbInventario.CodInventario)
{
return(BadRequest());
}
_context.Entry(tbInventario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TbInventarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <BDItem> > PostTodoItem(BDItem BDItem)
{
_context.BDItems.Add(BDItem);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBDItem", new { id = BDItem.Id }, BDItem));
}
public async Task <IActionResult> PutRol(int id, Rol rol)
{
if (id != rol.IdRol)
{
return(BadRequest());
}
_context.Entry(rol).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RolExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <object> auth(Usuarios usuario)
{
Usuarios _usuario = await _ctx.Usuarios.FirstOrDefaultAsync(u => u.Correo == usuario.Correo && u.Contrasena == usuario.Contrasena);
if (_usuario != null)
{
if (_usuario.Estatus)
{
var token = _jwt.Create(usuario.Correo);
_usuario.Token = token.AccessToken;
if (await _ctx.SaveChangesAsync() > 0)
{
_manager.Activate(_usuario.Token);
return(new
{
_usuario.Correo,
_usuario.Usuario,
_usuario.Contrasena,
_usuario.Sexo,
_usuario.FechaCreacion,
_usuario.Token
});
}
}
return(null);
}
return(null);
}
PutTbProducto(int id, TbProducto tbProducto)
{
if (id != tbProducto.CodProducto)
{
return(BadRequest());
}
tbProducto.FechaModificacion = DateTime.Now;
_context.Entry(tbProducto).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TbProductoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(Pedido pedido)
{
if (ModelState.IsValid)
{
try
{
_context.Update(pedido);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PedidoExists(pedido.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UsuarioId"] = new SelectList(_context.Usuarios, "Id", "Id", pedido.UsuarioId);
return(View(pedido));
}
public async Task<IActionResult> PutTbTransaccion(int id, TbTransaccion tbTransaccion)
{
if (id != tbTransaccion.CodTransaccion)
{
return BadRequest();
}
_context.Entry(tbTransaccion).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TbTransaccionExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return NoContent();
}
public async Task <IActionResult> Create([Bind("Id,Nome,Preco,Categoria")] Produto produto)
{
if (ModelState.IsValid)
{
_context.Add(produto);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(produto));
}
public async Task <IActionResult> Create([Bind("Id,Nome,Email,Cpf")] Usuario usuario)
{
if (ModelState.IsValid)
{
_context.Add(usuario);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(usuario));
}
public async Task <IActionResult> editar(int id, RegisterModel usuario)
{
if (id != usuario.cod_usuario)
{
return(BadRequest());
}
Usuario reg = _context.Usuario.Find(usuario.cod_usuario);
if (reg.correo_electronico != usuario.correo_electronico)
{
if (_context.Usuario.Any(x => x.correo_electronico == usuario.correo_electronico))
{
return(BadRequest());
}
}
reg.nombre_completo = usuario.nombre_completo;
reg.estado = usuario.estado;
reg.fec_creacion = DateTime.Now;
reg.cod_rol = usuario.cod_rol;
reg.correo_electronico = usuario.correo_electronico;
if (!string.IsNullOrWhiteSpace(usuario.contrasenia))
{
byte[] passwordHash, passwordSalt;
CreatePasswordHash(usuario.contrasenia, out passwordHash, out passwordSalt);
reg.contrasenia = passwordHash;
reg.salt = passwordSalt;
}
_context.Entry(reg).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuariosExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] object obj)
{
var value = ConvertValue <RegisterChallengModel>(obj);
var arr = value.Challenge.Split('.', StringSplitOptions.RemoveEmptyEntries);
var base64 = arr[0];
var challenge = arr[1];
var secret = Convert.FromBase64String(base64);;
var preseqence = Encoding.UTF8.GetString(secret);
var checkValue = preseqence + $"{DateTime.Today:dd.MM.yyyy}" + Secret;
var challengeVerification = string.Empty;
using (var sha2 = new SHA256Managed())
{
var data = Encoding.UTF8.GetBytes(checkValue);
var sha = sha2.ComputeHash(data);
challengeVerification = BitConverter.ToString(sha).Replace("-", "").ToLowerInvariant();
}
if (!string.Equals(challengeVerification, challenge))
{
return(Forbid());
}
var bytes = new byte[(152 / 8) * 6];
var rand = new Random((int)DateTime.Now.ToFileTime());
rand.NextBytes(bytes);
var auth = Convert.ToBase64String(bytes);
var user = await _bdContext.Users.FirstOrDefaultAsync(x => x.RegSecret == secret) ??
new Users
{
RegSecret = secret
};
user.LastLogin = DateTime.Now;
if (user.Id == 0)
{
_bdContext.Users.Add(user);
}
var session = new Sessions()
{
Expire = DateTime.Today.AddYears(1),
Token = auth,
User = user
};
_bdContext.Sessions.Add(session);
await _bdContext.SaveChangesAsync();
return(Ok(new RegisterResponse {
Auth = auth
}));
}
public async Task <IActionResult> PutUsuario(int id, Usuario model)
{
if (id != model.IdUsuario)
{
return(BadRequest());
}
var data = await _context.Roles.FirstOrDefaultAsync(x => x.IdRol == model.IdRol);
if (data == null)
{
return(NotFound("El rol asignado no existe"));
}
var rol = await _context.Roles.FirstOrDefaultAsync(x => x.IdRol == model.IdRol);
if (rol.IdRol != model.IdRol)
{
return(NotFound("No esta permitido asignarle otro rol al usuario"));
}
_context.Entry(model).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}