400 lines
14 KiB
C#
400 lines
14 KiB
C#
using MSAdminUsuarios.Context;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using MSAdminUsuarios.Dto;
|
|
using Security;
|
|
using MSAdminUsuarios.Models;
|
|
using Microsoft.AspNetCore.Components.Forms;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace MSAdminUsuarios.Controllers
|
|
{
|
|
[ApiController]
|
|
[Route("[controller]")]
|
|
public class UsuariosController : ControllerBase
|
|
{
|
|
private readonly ModelContext _context;
|
|
private readonly Encripter _encript = new();
|
|
|
|
public UsuariosController(ModelContext context)
|
|
{
|
|
_context = context;
|
|
}
|
|
|
|
[HttpPost("UserBene")]
|
|
public async Task<IActionResult> PostUserBeneficiario(string TX_IDENTIFICACION_AFIL)
|
|
{
|
|
ErrorModel _errorModel = new ErrorModel();
|
|
try
|
|
{
|
|
if (TX_IDENTIFICACION_AFIL == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Ingrese un dato");
|
|
return Ok(_errorModel);
|
|
}
|
|
|
|
USUARIO user = new USUARIO();
|
|
|
|
user.TX_PKDOC_USUMS = TX_IDENTIFICACION_AFIL;
|
|
user.TX_LOGINNAME_USUMS = TX_IDENTIFICACION_AFIL;
|
|
user.TX_PASSWORD_USUMS = _encript.EncryptPwd(TX_IDENTIFICACION_AFIL);
|
|
|
|
_context.USUARIOSMs.Add(user);
|
|
await _context.SaveChangesAsync();
|
|
|
|
_errorModel.error = false;
|
|
_errorModel.cuerpo.Add("Usuario creado");
|
|
return Ok(_errorModel);
|
|
|
|
}
|
|
catch (Exception)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Problemas con la base de datos");
|
|
return BadRequest(_errorModel);
|
|
|
|
}
|
|
}
|
|
|
|
[HttpGet("Iniciales")]
|
|
public async Task<IActionResult> GetIniciales(string TX_PKDOC_USUMS)
|
|
{
|
|
try
|
|
{
|
|
var consulta = _context.USUARIOSMs.FirstOrDefault(x => x.TX_PKDOC_USUMS == TX_PKDOC_USUMS);
|
|
|
|
var ininame = consulta.TX_PRIMERNOM_USUMS.ToCharArray();
|
|
var iniape = consulta.TX_PRIMERAPELL_USUMS.ToCharArray();
|
|
|
|
NameObject nombreObjeto = new NameObject()
|
|
{
|
|
iniciales = ininame[0].ToString() + iniape[0].ToString(),
|
|
nombre = consulta.TX_PRIMERNOM_USUMS.ToString() + " " + consulta.TX_PRIMERAPELL_USUMS.ToString(),
|
|
pk = consulta.NU_PK_USUMS,
|
|
};
|
|
|
|
return Ok(nombreObjeto);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex);
|
|
}
|
|
}
|
|
|
|
[HttpGet]
|
|
public async Task<IActionResult> GetUsuarios()
|
|
{
|
|
try
|
|
{
|
|
List<USUARIO> consulta = new List<USUARIO>();
|
|
|
|
consulta = (from dm in _context.USUARIOSMs
|
|
where dm.NU_ESTADO_USUMS >= 0
|
|
select dm).ToList();
|
|
|
|
return Ok(consulta);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex);
|
|
}
|
|
}
|
|
|
|
|
|
[HttpPost]
|
|
public async Task<IActionResult> GuardarUsuarios(USUARIO usuario)
|
|
{
|
|
try
|
|
{
|
|
if (usuario == null) return Conflict();
|
|
|
|
if (usuario.TX_CORREO_USUMS == null) return Conflict("Indique algún correo.");
|
|
|
|
var login_name = usuario.TX_CORREO_USUMS.Split('@');
|
|
|
|
var existe_login = _context.USUARIOSMs.Where(x => x.TX_LOGINNAME_USUMS == login_name[0]).Count();
|
|
|
|
if (existe_login > 0) return Conflict("El login ya está en uso");
|
|
|
|
usuario.TX_LOGINNAME_USUMS = login_name[0];
|
|
|
|
if (usuario.TX_PKDOC_USUMS == null)
|
|
{
|
|
var ult = _context.USUARIOSMs.Max(x => x.NU_PK_USUMS) + 1;
|
|
usuario.TX_PKDOC_USUMS = ult.ToString();
|
|
}
|
|
|
|
if (usuario.TX_PASSWORD_USUMS != null)
|
|
{
|
|
usuario.TX_PASSWORD_USUMS = _encript.EncryptPwd(usuario.TX_PASSWORD_USUMS);
|
|
}
|
|
|
|
|
|
|
|
_context.USUARIOSMs.Add(usuario);
|
|
await _context.SaveChangesAsync();
|
|
return Ok();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return BadRequest(ex.Message);
|
|
}
|
|
}
|
|
|
|
[HttpPatch]
|
|
public async Task<IActionResult> EditarUsuarios(USUARIO editado)
|
|
{
|
|
ErrorModel _errorModel = new ErrorModel();
|
|
|
|
using (var dbContextTransaction = _context.Database.BeginTransaction())
|
|
{
|
|
try
|
|
{
|
|
if (editado == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Ingrese datos");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
var existe = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == editado.NU_PK_USUMS);
|
|
|
|
if (existe == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("El usuario que desea editar no existe");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
existe.TX_PRIMERNOM_USUMS = editado.TX_PRIMERNOM_USUMS;
|
|
existe.TX_SEGUNDONOM_USUMS = editado.TX_SEGUNDONOM_USUMS;
|
|
existe.TX_PRIMERAPELL_USUMS = editado.TX_PRIMERAPELL_USUMS;
|
|
existe.TX_SEGUNDONOM_USUMS = editado.TX_SEGUNDONOM_USUMS;
|
|
existe.TX_CELULAR_USUMS = editado.TX_CELULAR_USUMS;
|
|
existe.TX_TELEFONO_USUMS = editado.TX_TELEFONO_USUMS;
|
|
existe.TX_CORREO_USUMS = editado.TX_CORREO_USUMS;
|
|
existe.TX_DIRECCION_USUMS = editado.TX_DIRECCION_USUMS;
|
|
|
|
ErrorModel errorPFLxUSUMS = await ActualizarRelaciones(existe.TX_PKDOC_USUMS, editado.TX_PKDOC_USUMS);
|
|
|
|
if (errorPFLxUSUMS.error == true)
|
|
{
|
|
_errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
_errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
|
|
|
|
existe.NU_TIPODOC_USUMS = editado.NU_TIPODOC_USUMS;
|
|
existe.TX_PKDOC_USUMS = editado.TX_PKDOC_USUMS;
|
|
|
|
_context.USUARIOSMs.Update(existe);
|
|
_context.SaveChanges();
|
|
|
|
_errorModel.error = false;
|
|
_errorModel.cuerpo.Add("Usuario actualizado.");
|
|
dbContextTransaction.Commit();
|
|
return Ok(_errorModel);
|
|
}
|
|
catch
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Problema con la base de datos.");
|
|
dbContextTransaction.Rollback();
|
|
return BadRequest(_errorModel);
|
|
}
|
|
}
|
|
}
|
|
|
|
[HttpPatch("NumeroDocumento")]
|
|
public async Task<IActionResult> EditarNoDocumentoUsuarios(USUARIO editado)
|
|
{
|
|
ErrorModel _errorModel = new ErrorModel();
|
|
|
|
using (var dbContextTransaction = _context.Database.BeginTransaction())
|
|
{
|
|
try
|
|
{
|
|
if (editado == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Ingrese datos");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
var existe = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == editado.NU_PK_USUMS);
|
|
|
|
if (existe == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("El usuario que desea editar no existe");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
if (existe.TX_PKDOC_USUMS != editado.TX_PKDOC_USUMS || existe.NU_TIPODOC_USUMS != editado.NU_TIPODOC_USUMS)
|
|
{
|
|
ErrorModel errorPFLxUSUMS = await ActualizarRelaciones(existe.TX_PKDOC_USUMS, editado.TX_PKDOC_USUMS);
|
|
|
|
if(errorPFLxUSUMS.error == true) {
|
|
_errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
_errorModel.listaErrores.Add(errorPFLxUSUMS.cuerpo[0]);
|
|
|
|
existe.NU_TIPODOC_USUMS = editado.NU_TIPODOC_USUMS;
|
|
existe.TX_PKDOC_USUMS = editado.TX_PKDOC_USUMS;
|
|
}
|
|
|
|
_context.USUARIOSMs.Update(existe);
|
|
await _context.SaveChangesAsync();
|
|
|
|
_errorModel.error = false;
|
|
_errorModel.cuerpo.Add("Documento y tipo actualizados.");
|
|
dbContextTransaction.Commit();
|
|
return Ok(_errorModel);
|
|
}
|
|
catch
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Problema con la base de datos.");
|
|
dbContextTransaction.Rollback();
|
|
return BadRequest(_errorModel);
|
|
}
|
|
}
|
|
}
|
|
|
|
[HttpPatch("Perfil_usu")]
|
|
public async Task<ErrorModel> ActualizarRelaciones(string TX_PKDOC_USUMS_anterior, string TX_PKDOC_USUMS_nuevo)
|
|
{
|
|
var _errorModel = new ErrorModel();
|
|
try
|
|
{
|
|
var existe_any = _context.PERFILESPORUSUARIOs.FirstOrDefault(x => x.TX_FKDOC_USUMS == TX_PKDOC_USUMS_anterior);
|
|
|
|
if (existe_any == null)
|
|
{
|
|
_errorModel.error = false;
|
|
_errorModel.cuerpo.Add($"No existen Perfiles para {TX_PKDOC_USUMS_anterior}");
|
|
return _errorModel;
|
|
}
|
|
|
|
List<PERFILPORUSUARIO> existe = _context.PERFILESPORUSUARIOs.Where(x => x.TX_FKDOC_USUMS == TX_PKDOC_USUMS_anterior).ToList();
|
|
|
|
foreach (var r in existe)
|
|
{
|
|
r.TX_FKDOC_USUMS = TX_PKDOC_USUMS_nuevo;
|
|
_context.PERFILESPORUSUARIOs.Update(r);
|
|
}
|
|
|
|
await _context.SaveChangesAsync();
|
|
_errorModel.error = false;
|
|
_errorModel.cuerpo.Add("Perfiles Actualizados.");
|
|
return _errorModel;
|
|
|
|
}
|
|
catch
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Problema con la base de datos PERFILES POR USUARIO.");
|
|
return _errorModel;
|
|
}
|
|
}
|
|
|
|
[HttpPatch("Firma")]
|
|
public async Task<IActionResult> EditarFirma(USUARIO inputData)
|
|
{
|
|
ErrorModel _errorModel = new();
|
|
using (var dbContextTransaction = _context.Database.BeginTransaction())
|
|
{
|
|
try
|
|
{
|
|
|
|
#region Validaciones
|
|
|
|
if ((inputData == null || inputData.CL_FIRMA_USUMS == null) ||
|
|
(String.IsNullOrEmpty(inputData.CL_FIRMA_USUMS.Trim()) ||
|
|
String.IsNullOrWhiteSpace(inputData.CL_FIRMA_USUMS.Trim())))
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("No se recibió la información requerida.");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
#endregion
|
|
|
|
// Busco el usuario
|
|
var found = _context.USUARIOSMs.FirstOrDefault(x => x.NU_PK_USUMS == inputData.NU_PK_USUMS);
|
|
|
|
if (found == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("El usuario seleccionado no existe.");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
found.CL_FIRMA_USUMS = inputData.CL_FIRMA_USUMS;
|
|
|
|
_context.USUARIOSMs.Update(found);
|
|
await _context.SaveChangesAsync();
|
|
|
|
await dbContextTransaction.CommitAsync();
|
|
|
|
_errorModel.cuerpo.Add("Firma actualizada correctamente.");
|
|
return Ok(_errorModel);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
dbContextTransaction.Rollback();
|
|
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Ocurrió un error en la base de datos.");
|
|
_errorModel.cuerpo.Add("Por favor intente de nuevo más tarde");
|
|
|
|
//_errorModel.debugInfo(e.InnerException.ToString());
|
|
|
|
return BadRequest(_errorModel);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
[HttpGet("Firma")]
|
|
public async Task<IActionResult> Get(int PK)
|
|
{
|
|
ErrorModel _errorModel = new ErrorModel();
|
|
try
|
|
{
|
|
var result = await _context.USUARIOSMs.FirstOrDefaultAsync(dt => dt.NU_PK_USUMS == PK);
|
|
|
|
if(result == null)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Usuario no encontrado");
|
|
return BadRequest(_errorModel);
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(result.CL_FIRMA_USUMS) ||
|
|
String.IsNullOrWhiteSpace(result.CL_FIRMA_USUMS.Trim()))
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("El usuario no tiene firma.");
|
|
return Conflict(_errorModel);
|
|
}
|
|
|
|
return Ok(result.CL_FIRMA_USUMS);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
_errorModel.error = true;
|
|
_errorModel.cuerpo.Add("Problema con la base de datos.");
|
|
|
|
return BadRequest(_errorModel);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|