AuditLogs/audit-logs/README.md

# Integración de la Biblioteca AuditLogs

## Configuración y Uso de AuditLogs

Este documento es una guia para la utilización de la biblioteca `AuditLogs` en aplicaciones .NET que requieren funcionalidades de auditoría mediante MongoDB.

### Configuración Inicial

#### 1. Configuración en `appsettings.json`

Agregue la siguiente configuración para la conexión a la base de MongoDB que usara la biblioteca, esto se pone en el archivo `appsettings.json`:

```json
"DatabaseConfigurationAudit": {
    "ConnectionString": "mongodb://usuario:contraseña@host:puerto/?authSource=base_de_datos_autenticación",
    "DatabaseName": "AuditMeddisPlanUciPanel"
}
```

#### 2. Instalación de la Biblioteca

Instale la biblioteca `AuditLogs` a través de NuGet con el siguiente comando:

```bash
dotnet add package AuditLogs
```
previamente se tuvo que haber configurado esta fuente https://smacs-nuget.epigramdev.com/v3/index.json

#### 3. Configuración en `Program.cs`

Para configurar los servicios de la biblioteca en el archivo Program.cs, se debe incluir el espacio de nombres audit_logs.Extensions y ejecutar el método AddAuditServices:

```csharp
using audit_logs.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Configuración de servicios de auditoría
builder.Services.AddAuditServices(builder.Configuration);
builder.Services.AddHttpContextAccessor();
```
### 4. Modificación de la generación del token para incluir información (Opcional)
El servicio de autoría utiliza httpContext para extraer información del usuario que está haciendo los cambios, usted puede incluir más información si hace cambios en su modelo de usuario por ejemplo agregando un atributo Ip
```csharp
using MongoDB.Bson;
namespace smacs_uci_api.Domain.Models.MongoModels
{ 
    public class User {
         public ObjectId Id { get; set; }
         public string Name { get; set; } = string.Empty;
         public string Email { get; set; } = string.Empty;
         public string IpAddress { get; set; } = string.Empty; 
         //otros datos 
    }
 }
 ```

Luego en la parte donde se hace la autenticación en este caso clase UserService puede modificar la creación del token para agregar esta información
```csharp
 public TokenResult GenerateJwt(User user)
        {           
            // Claims basicos del usuario
            var claims = new List<Claim>
            {
                new Claim(ClaimTypes.Name, user.UserName),
                new Claim(ClaimTypes.Email, user.Email),
                new Claim("IpAddress", user.IpAddress)
            };

            // Agregar claims de autorizaciones utilizando ClaimsFromAuthorities
            claims.AddRange(ClaimsFromAuthorities(user.Authorization));
            
           // mas logica para este metodos...
            
            return new TokenResult
            {
                AccessToken = new JwtSecurityTokenHandler().WriteToken(accessToken),
                RefreshToken = new JwtSecurityTokenHandler().WriteToken(refreshToken),
                AccessTokenExpiryTime = accessToken.ValidTo,
                RefreshTokenExpiryTime = refreshToken.ValidTo,
                User = user
            };
        }
}
```
 
 la biblioteca buscará el parámetro IpAddress y lo configura en el registro de autoría, si no se envia pondrá un valor por defecto


### Uso en Servicios

Implemente `IAuditService` en los servicios donde se requiera registrar eventos de auditoría.
El servicio de admisiones, por ejemplo, puede configurarse de la siguiente manera, donde se inyecta IAuditService y IHttpContextAccessor para registrar eventos de auditoría relacionados con las admisiones de pacientes:

#### Ejemplo en el Servicio de Admisiones

```csharp
public class AdmissionService : IAdmissionService
{
    private readonly IAuditService _auditService;
    private readonly IHttpContextAccessor _httpContextAccessor;
    // Inyección de otros servicios necesarios...

    public AdmissionService(IAuditService auditService, IHttpContextAccessor httpContextAccessor, /* otros parámetros */)
    {
        _auditService = auditService;
        _httpContextAccessor = httpContextAccessor;
        // Inicialización de otros servicios...
    }

    public async Task AdmitPatient(Patient patient)
    {
        var httpContext = _httpContextAccessor.HttpContext;
        var insertedAdmission = /* lógica para admitir al paciente */;
        
        // Registro de evento de auditoría
        await _auditService.CreateAuditLogAsync(httpContext.User, null, insertedAdmission);
    }
}

```

## Creación de Controladores de Consulta

Para crear un controlador que permita consultar los registros de auditoría, siga este ejemplo:

```csharp
using audit_logs.Services.Interfaces;
using Microsoft.AspNetCore.Mvc;

namespace smacs_uci_api.Controllers
{
    [Route("Audit")]
    [ApiController]
    public class AuditController : ControllerBase
    {
        private readonly IAuditService _auditService;

        public AuditController(IAuditService auditService)
        {
            _auditService = auditService;
        }

        [HttpPost]
        public async Task<IActionResult> GetAuditRecordsByAnyTextField(
            [FromBody] audit_logs.Models.DTO.AuditLogTextOrDateSearchDTO auditRequestDto)
        {
            try
            {
                var result = await _auditService.GetAuditLogsMatchingTextOrDateAsync(auditRequestDto);
                return Ok(result);
            }
            catch (ArgumentException ex)
            {
                return BadRequest(ex.Message);
            }
        }
    }
}
```

Este controlador utiliza `IAuditService` para recuperar registros basados en texto y fechas especificadas por el usuario.