Initial commit

This commit is contained in:
Dlegoff
2026-09-18 23:35:22 -03:00
commit e3a0516fb6
358 changed files with 53511 additions and 0 deletions
+18
View File
@@ -0,0 +1,18 @@
root = true
[*]
charset = utf-8
end_of_line = lf
indent_size = 4
indent_style = space
insert_final_newline = true
trim_trailing_whitespace = true
[*.md]
trim_trailing_whitespace = false
[*.{yml,yaml}]
indent_size = 2
[docker-compose.yml]
indent_size = 4
+77
View File
@@ -0,0 +1,77 @@
APP_NAME=M-GAP
APP_ENV=local
APP_KEY=
APP_DEBUG=true
APP_TIMEZONE=America/Argentina/Buenos_Aires
APP_URL=http://localhost:8000
APP_LOCALE=es
APP_FALLBACK_LOCALE=es
APP_FAKER_LOCALE=en_US
APP_MAINTENANCE_DRIVER=file
# APP_MAINTENANCE_STORE=database
PHP_CLI_SERVER_WORKERS=4
BCRYPT_ROUNDS=12
LOG_CHANNEL=stack
LOG_STACK=single
LOG_DEPRECATIONS_CHANNEL=null
LOG_LEVEL=debug
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=m-gap
DB_USERNAME=root
DB_PASSWORD=
# AES-256 encryption password for database backups (required for backup:create)
BACKUP_PASSWORD=CambiarClave123+
BACKUP_RETENTION=15
BACKUP_DISK=backups
# Path to mysqldump (default assumes XAMPP on C:/xampp)
# BACKUP_MYSQLDUMP_PATH=C:/xampp/mysql/bin/mysqldump.exe
# Path to 7-Zip executable (required for encrypted backups)
# BACKUP_7ZIP_PATH=C:/Program Files/7-Zip/7z.exe
SESSION_DRIVER=database
SESSION_LIFETIME=120
SESSION_ENCRYPT=false
SESSION_PATH=/
SESSION_DOMAIN=null
BROADCAST_CONNECTION=log
FILESYSTEM_DISK=local
QUEUE_CONNECTION=database
CACHE_STORE=database
CACHE_PREFIX=
MEMCACHED_HOST=127.0.0.1
REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
MAIL_MAILER=smtp
MAIL_HOST=sandbox.smtp.mailtrap.io
MAIL_PORT=2525
MAIL_USERNAME="de05a4696efaa1"
MAIL_PASSWORD="ab6d13588afc8a"
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS="mgaprecuperation@gmail.com"
MAIL_FROM_NAME="${APP_NAME}"
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=
AWS_USE_PATH_STYLE_ENDPOINT=false
VITE_APP_NAME="${APP_NAME}"
+11
View File
@@ -0,0 +1,11 @@
* text=auto eol=lf
*.blade.php diff=html
*.css diff=css
*.html diff=html
*.md diff=markdown
*.php diff=php
/.github export-ignore
CHANGELOG.md export-ignore
.styleci.yml export-ignore
+33
View File
@@ -0,0 +1,33 @@
/.phpunit.cache
/node_modules
/public/build
/public/hot
/public/storage
/storage/*.key
/storage/pail
/storage/logs
/storage/app/private/backups
/storage/app/private/temp_restore_*
/storage/framework/views
/storage/framework/cache/data
/storage/framework/sessions
/storage/framework/testing
/vendor
/.vite
.env
.env.backup
.env.production
.phpactor.json
.phpunit.result.cache
Homestead.json
Homestead.yaml
npm-debug.log
yarn-error.log
/auth.json
/.fleet
/.idea
/.nova
/.vscode
/.zed
/~
jsconfig.json
+583
View File
@@ -0,0 +1,583 @@
# M GAP (Gestión de Activos y Permisos)
M GAP es una plataforma integral de **Gestión de Riesgos, Activos y Control de Acceso**, diseñada para cumplimiento normativo (ISO 27001, PCI-DSS, BCRA). Centraliza la gestión de activos, identifica vulnerabilidades asociadas a amenazas y aplica controles para mitigar riesgos operativos y de ciberseguridad.
---
## Características Principales
- **Gestión de Activos (Recursos)**: Inventario, clasificación por tipo e impacto, asignación a áreas y usuarios con trazabilidad histórica.
- **Gestión de Amenazas**: Registro de amenazas con nivel de amenaza, clasificación por tipo y vinculación a vulnerabilidades.
- **Gestión de Vulnerabilidades**: Control de vulnerabilidades con severidad y vinculación a recursos y amenazas.
- **Gestión de Riesgos**: Cálculo automático del riesgo inherente y residual según la metodología documentada en [Cálculo de Riesgo](#cálculo-de-riesgo-iso-27001).
- **Controles Mitigantes**: Asignación histórica de controles a riesgos, con nivel de control y estados de vida (Planificado / En revisión / Implementado).
- **Control de Acceso**: Autorización de la aplicación mediante cuatro roles de sistema fijos, independiente del modelo de permisos del dominio GRC.
- **Auditoría**: Registro histórico de cambios con trazabilidad de usuario, dirección IP y timestamp.
- **Notificaciones**: Alertas automáticas por vencimiento de permisos y asignaciones para el usuario autenticado.
- **Dashboards y Reportes**: Dashboard principal, dashboards temáticos, reportes de permisos y cobertura, exportación a Excel/PDF y exportación CSV en listados.
- **Backups**: Copias de seguridad generadas con compresión y cifrado, además de carga, descarga y restauración.
---
## Stack Tecnológico
| Capa | Tecnología |
|------|-----------|
| Backend | Laravel 11 (PHP 8.2+) |
| Frontend | React 18 + Inertia.js v2 |
| UI | Material UI (MUI) v5 + Tailwind CSS |
| Build | Vite |
| Base de datos | MySQL (principal)|
| Autorización | `spatie/laravel-permission` con tablas `auth_*` |
| Rutas frontend | Ziggy (`route()` global) |
---
## Requisitos previos
Para ejecutar M-GAP en Windows se requiere:
- Windows 10/11
- XAMPP
- PHP 8.2 o superior
- MySQL/MariaDB
- Composer
- Node.js y npm
- Git
- 7-Zip (requerido para la funcionalidad de backups)
### Verificar instalación
Abrir una terminal y ejecutar:
```bash
php -v
composer -V
node -v
npm -v
git --version
### XAMPP
Instalar XAMPP y abrir el panel de control.
Para M-GAP es necesario iniciar:
- MySQL
Apache no es necesario para ejecutar la aplicación, ya que Laravel utiliza
su propio servidor de desarrollo mediante `php artisan serve`.
Se puede utilizar phpMyAdmin para crear y administrar la base de datos.
## Instalación
```bash
git clone <URL_DEL_REPOSITORIO>
cd m-gap
composer install
npm install
cp .env.example .env
php artisan key:generate
# Configurar las variables DB_* de MySQL en .env
php artisan migrate --seed
npm run dev
# En otra terminal:
php artisan serve
# La aplicación estará disponible en http://localhost:8000
```
MySQL es la base de datos principal del proyecto. El archivo `.env.example` incluye SQLite como configuración inicial de ejemplo; al copiarlo, completar las variables `DB_*` con la conexión MySQL correspondiente. Los tests utilizan SQLite en memoria mediante `phpunit.xml`.
Para levantar el stack completo de desarrollo (servidor Laravel, worker de cola, logs de Pail y Vite):
```bash
composer run dev
```
### Seeders
```bash
php artisan db:seed # Ejecuta DatabaseSeeder completo
php artisan db:seed --class=GrcDemoSeeder # Datos demo GRC base
php artisan db:seed --class=DatosDemoSeeder # Ampliación de datos demo
php artisan db:seed --class=RolesSistemaSeeder # Roles y usuarios del sistema
php artisan migrate:refresh --seed --seeder=DashboardMassiveSeeder # Dataset masivo alternativo
php artisan migrate:refresh --seed # Reconstruye la base y carga DatabaseSeeder
```
`DatabaseSeeder` ejecuta, en este orden:
1. Crea `test@example.com` si todavía no existe.
2. Ejecuta `GrcDemoSeeder` con los datos GRC base.
3. Ejecuta `DatosDemoSeeder` con datos demo adicionales y relaciones históricas.
4. Ejecuta `RolesSistemaSeeder` con los roles de autenticación y usuarios de ejemplo.
`DatosDemoSeeder` requiere los datos base que aporta `GrcDemoSeeder`; para evitar dependencias incompletas, se recomienda ejecutar `php artisan db:seed` mediante `DatabaseSeeder` en lugar de invocarlo de forma aislada. `DashboardMassiveSeeder` es un dataset alternativo, requiere una base de negocio vacía y se ejecuta una sola vez por ciclo de migraciones. Los seeders demo solo están habilitados en entornos `local` y `testing`; en otros entornos `DatabaseSeeder` se limita a crear los roles del sistema sin cuentas demo.
Credenciales de desarrollo por defecto, todas con contraseña `Password@1`:
| Usuario | Rol del sistema |
|---------|-----------------|
| `test@example.com` | `administrador` |
| `visor@example.com` | `visor` |
| `consultor@example.com` | `consultor` |
| `pendiente@example.com` | `pendiente` |
Los usuarios registrados mediante el formulario público reciben el rol `consultor` por defecto.
Los seeders coordinan sus asignaciones históricas para no duplicar a Roberto Fernández como responsable de Sistemas y Ciberseguridad.
Los seeders son idempotentes dentro de un mismo ciclo de migraciones. Repetir `php artisan db:seed` sin refrescar la base no duplica pivotes históricos ni sobrescribe cambios manuales sobre registros existentes. También se preservan las contraseñas y los roles de sistema ya asignados. `RolesSistemaSeeder` solo asigna el rol predeterminado correspondiente a cada cuenta demo que todavía no tenga ningún rol.
La tabla `seeder_runs` registra las cargas no repetibles: protege los eventos demo de `GrcDemoSeeder` y `DatosDemoSeeder`, marca el dataset estándar como excluyente del masivo y protege la carga completa de `DashboardMassiveSeeder`. Al ejecutar `php artisan migrate:refresh --seed`, todas las tablas se reconstruyen, `seeder_runs` vuelve a crearse vacía y se cargan nuevamente todos los datos incluidos en `DatabaseSeeder`. Para usar el dataset masivo en lugar del demo estándar, ejecutar `php artisan migrate:refresh --seed --seeder=DashboardMassiveSeeder`. Ambos datasets calculan sus riesgos con la metodología documentada después de crear las relaciones históricas y los controles.
---
## Comandos Disponibles
| Comando | Descripción |
|---------|-------------|
| `php artisan serve` | Servidor de desarrollo local |
| `composer run dev` | Laravel server + queue + Pail + Vite en paralelo |
| `npm run dev` | Servidor de desarrollo Vite |
| `npm run build` | Build de producción |
| `php artisan migrate:refresh --seed` | Reconstruir la base y volver a cargar `DatabaseSeeder` |
| `php artisan db:seed` | Ejecutar `DatabaseSeeder` de forma idempotente |
| `php artisan migrate:refresh --seed --seeder=DashboardMassiveSeeder` | Reconstruir la base con el dataset masivo alternativo para dashboards |
| `php artisan test` | Ejecutar todos los tests PHPUnit |
| `php artisan test --filter=RiesgoManagementTest` | Tests específicos de riesgos |
| `php artisan riesgos:recalcular` | Recalcular los scores de riesgos activos |
| `php artisan backup:create {--frequency=}` | Crear un backup cifrado de la base de datos |
| `php artisan backup:restore {backupId}` | Restaurar un backup desde CLI |
| `php artisan permission:cache-reset` | Limpiar la caché de roles y permisos |
| `vendor/bin/pint` | Formatear código PHP con Laravel Pint |
Los comandos `riesgos:recalcular` y `backup:create` están programados en `routes/console.php`. El primero se ejecuta diariamente y el segundo cada minuto. `backup:create` lee la configuración de `backup_settings` (frecuencia, `is_active`, `run_time`, `run_day`) y ejecuta el backup solo cuando coincide el día y la hora configurados. Las invocaciones manuales con `--frequency=manual` siempre se ejecutan ignorando la configuración.
Para que las tareas programadas se ejecuten, algo tiene que invocar `php artisan schedule:run` cada minuto. En este proyecto se usa una tarea del Programador de tareas de Windows (`M-GAP Backup Scheduler`) que ejecuta `backup-scheduler.bat` cada minuto a través de un launcher oculto (`backup-scheduler-hidden.vbs`). En Linux se usaría cron ejecutando el mismo comando.
La `run_time` se interpreta en la zona horaria de `APP_TIMEZONE` (definida en `.env`).
---
## Cálculo de Riesgo ISO 27001
El sistema calcula automáticamente el nivel de riesgo inherente y residual para cada riesgo registrado.
### Fórmula
```text
P_inherente = A + V
P_residual = max(0, P_inherente - C)
R_inherente = P_inherente × I
R_residual = P_residual × I
```
Donde:
| Variable | Descripción | Escala |
|----------|-------------|--------|
| **A** | Nivel de amenaza | 1-4 |
| **V** | Severidad de vulnerabilidad | 0-4 |
| **C** | Efectividad total de controles implementados | 1-4, con máximo 4 |
| **I** | Impacto del recurso | 1-4 |
#### Nivel de Amenaza (A)
| Nivel | Valor |
|-------|-------|
| Bajo | 1 |
| Medio | 2 |
| Alto | 3 |
| Crítico | 4 |
#### Severidad de Vulnerabilidad (V)
| Severidad | Valor |
|-----------|-------|
| Baja | 1 |
| Media | 2 |
| Alta | 3 |
| Crítica | 4 |
**Regla V=0:** cuando la relación histórica recurso-vulnerabilidad no está vigente (la fecha de fin fue alcanzada o no existe la relación), la severidad de vulnerabilidad se considera **0**.
#### Impacto del Recurso (I)
| Impacto | Valor |
|---------|-------|
| Bajo | 1 |
| Medio | 2 |
| Alto | 3 |
| Crítico | 4 |
#### Efectividad de Controles (C)
La efectividad se obtiene desde `controles.nivel_de_control`, no desde un valor independiente en el pivot:
| Nivel de control | Valor |
|------------------|-------|
| Débil | 1 |
| Parcial | 2 |
| Fuerte | 4 |
- Solo se contabilizan controles con estado **Implementado** y sin `fecha_fin` en la asignación `riesgo_control`.
- Si hay múltiples controles activos, se suman sus valores y el total se limita a un máximo de 4.
- El calculador aplica `LOWER()` antes de comparar, por lo que acepta cualquier capitalización (`fuerte`, `FUERTE`, `Fuerte`, etc.).
### Clasificación del Resultado (R)
| Rango de R | Nivel de Riesgo |
|------------|----------------|
| 0 - 4 | **Bajo** |
| 5 - 9 | **Medio** |
| 10 - 19 | **Alto** |
| 20 - 32 | **Crítico** |
El rango máximo teórico es 32 (`A=4`, `V=4`, `C=0`, `I=4`).
### Ejemplo Práctico
```text
Recurso: Base de Datos Tarjetas (Impacto = Crítico -> I=4)
Amenaza: Exposición de PAN (Nivel = Crítico -> A=4)
Vulnerabilidad: DB sin cifrado en reposo (Severidad = Crítica -> V=4)
Control: Tokenización PCI-DSS (Implementado, nivel Fuerte -> C=4)
P_inherente = 4 + 4 = 8
P_residual = max(0, 8 - 4) = 4
R_inherente = 8 x 4 = 32 -> Crítico
R_residual = 4 x 4 = 16 -> Alto
```
### Recálculo Automático
Los scores se recalculan cuando:
- Se crea un nuevo riesgo.
- Se edita un riesgo mediante sus operaciones de gestión.
- Se asocia, actualiza o desasocia un control del riesgo.
- Se actualiza el nivel de una amenaza; se recalculan inmediatamente todos sus riesgos activos relacionados.
- Se actualiza la severidad de una vulnerabilidad; se recalculan inmediatamente todos sus riesgos activos relacionados.
- Se ejecuta `php artisan riesgos:recalcular`, programado diariamente.
El comando `php artisan riesgos:recalcular` mantiene su función como recálculo global y mecanismo de reconciliación para todos los riesgos activos.
---
## Validación de Enums Canónicos
Los campos enumerados están validados en backend (Laravel `Rule::in` / `in:`) y frontend (Yup `.oneOf`). Valores no canónicos rechazan con error de validación. Las opciones de combo se centralizan en `resources/js/constants/enums.js` (módulo compartido) para `ESTADOS_CONTROL` y `NIVELES_CONTROL`.
| Campo | Valores válidos | Archivos backend | Archivos frontend |
|-------|----------------|-----------------|-------------------|
| `controles.estado` | `Implementado \| En revisión \| Planificado` | `ControlController`, `ControlGestionController` | `Controles/Create.jsx`, `Edit.jsx`, `Gestionar.jsx` |
| `controles.nivel_de_control` | `fuerte \| parcial \| debil` | `ControlController`, `ControlGestionController` | `Controles/Create.jsx`, `Edit.jsx`, `Gestionar.jsx` |
| `amenazas.nivel_de_amenaza` | `Bajo \| Medio \| Alto \| Crítico` | `AmenazaController`, `AmenazaGestionController` | `Amenazas/Create.jsx`, `Gestionar.jsx` |
| `amenazas.fuente` | `Interna \| Externa` | `AmenazaController`, `AmenazaGestionController` | `Amenazas/Create.jsx`, `Gestionar.jsx` |
| `amenazas.origen` | `Humana \| Natural \| Ambiental \| Tecnológica` | `AmenazaController`, `AmenazaGestionController` | `Amenazas/Create.jsx`, `Gestionar.jsx` |
| `vulnerabilidades.severidad` | `Baja \| Media \| Alta \| Crítica` | `StoreVulnerabilidadRequest`, `VulnerabilidadGestionController` | `Vulnerabilidades/Create.jsx`, `Gestionar.jsx` |
| `vulnerabilidades.fuente` | `Interna \| Externa \| Ambas` | `StoreVulnerabilidadRequest`, `VulnerabilidadGestionController` | `Vulnerabilidades/Create.jsx`, `Gestionar.jsx` |
| `recursos.impacto` | `Bajo \| Medio \| Alto \| Crítico` | `RecursoController`, `RecursoGestionController` | `Recursos/Create.jsx`, `Gestionar.jsx` |
| `permisos.estado` | `1 \| 0` | `PermisoController`, `PermisoGestionController` | `Permisos/Create.jsx` |
---
## Longitudes Máximas Canónicas
Los campos de texto tienen longitudes máximas validadas en backend (`max:`) y frontend (`.max()` + `inputProps maxLength`). Se aplican tanto al alta (store) como a la edición (update).
| Campo | Límite | Archivos principales |
|-------|--------|---------------------|
| `nombre`, `apellido` | 35 | Controllers, Create.jsx, Edit.jsx, Gestionar.jsx |
| `correo`, `telefono` | 35 | AreaController, UsuarioController, Create.jsx, Edit.jsx, Gestionar.jsx |
| `descripcion`, `justificacion`, `accion` | 185 | Controllers, Create.jsx, Edit.jsx, Gestionar.jsx |
| `documento` | 20 | UsuarioController, Usuarios/Create.jsx |
| `direccion`, `motivo_alta` | 35 | AreaController, Areas/Create.jsx |
---
## Control de Acceso
M GAP tiene dos modelos de roles independientes:
1. **Roles del sistema:** autorizan acciones en la aplicación y se implementan con `spatie/laravel-permission` sobre `users`.
2. **Roles del dominio GRC:** forman el modelo de negocio Usuario -> Rol -> Perfil -> Permiso mediante las tablas `usuarios`, `roles`, `perfiles` y `permisos`. No controlan el login ni la autorización de rutas.
Las tablas de Spatie utilizan el prefijo `auth_` (`auth_roles`, `auth_permissions`, `auth_model_has_roles`, entre otras) para evitar colisiones con las tablas de dominio.
### Roles del Sistema
| Rol | Acceso |
|-----|--------|
| `administrador` | Acceso total, incluyendo escritura, parametría, backups y seguridad. |
| `visor` | Lectura de módulos permitidos, exportación CSV, dashboards y reportes. Sin auditorías, notificaciones, backups, tipos ni seguridad. |
| `consultor` | Dashboards y reportes. |
| `pendiente` | Pantalla de bienvenida. Sin acceso a módulos. Se asigna a nuevos registros y al cambiar el rol desde administración. |
- Las rutas utilizan el alias `role:` de `RoleMiddleware`, registrado en `bootstrap/app.php`.
- Los errores HTTP 403 renderizan `resources/js/Pages/Error.jsx` mediante Inertia.
- La gestión de roles del sistema se realiza en `/seguridad/usuarios`, solo para administradores.
- Un administrador no puede quitarse a sí mismo el rol `administrador`.
- `HandleInertiaRequests` comparte `auth.roles` con el frontend.
- `resources/js/utils/permissions.js` expone `useRoles()` y `useCanWrite()`.
- `Sidebar.jsx` filtra las opciones visibles según el rol, pero la autorización efectiva siempre se valida en el backend.
- Después de cambiar roles o permisos en código, ejecutar `php artisan permission:cache-reset`.
---
## Dashboards y Reportes
### Dashboards
| Ruta | Descripción |
|------|-------------|
| `/tablero` | Tablero General: métricas generales, distribución de riesgos inherentes/residuales, cobertura de controles y matriz vulnerabilidad × impacto. |
| `/tablero/accesos` | Métricas de accesos y permisos: usuarios, roles, perfiles por permisos y perfiles por rol. |
| `/tablero/riesgos` | Análisis de riesgos. |
| `/tablero/cumplimiento` | Indicadores de cumplimiento: controles, cobertura, treemap con drilldown de recursos por tipo y estado de revisiones. |
| `/tablero/catalogo-activos` | Catálogo de activos: inventario, distribución por tipo, impacto, áreas y asignaciones. |
Los dashboards están disponibles para los tres roles del sistema.
### Reportes
| Ruta | Descripción |
|------|-------------|
| `/reportes` | Panel principal de reportes. |
| `/reportes/permisos-efectivos` | Matriz de permisos efectivos Usuario -> Rol -> Perfil -> Permiso vigente. |
| `/reportes/permisos-nuevos` | Permisos otorgados en un rango de fechas. |
| `/reportes/permisos-baja` | Permisos dados de baja. |
| `/reportes/permisos-expiran` | Permisos próximos a vencer. |
| `/reportes/acceso-recursos` | Acceso a recursos, usuarios y perfiles, incluyendo recursos sin asignar. |
| `/reportes/relaciones-cobertura` | Matriz recursos x perfiles y distribución por tipo. |
Los reportes contienen filtros interactivos y posibilidad de exportan a Excel y PDF.
---
## Notificaciones
`NotificacionService` genera alertas bajo demanda al cargar páginas Inertia autenticadas, deduplicadas sin repetir el mismo título dentro de siete días, para:
- Permisos de perfiles vencidos o próximos a vencer.
- Asignaciones de recursos, áreas y perfiles vencidas o próximas a vencer.
- Relaciones cuya fecha de vencimiento está dentro de los próximos siete días.
Las notificaciones se vinculan al usuario de login mediante la correspondencia `users.email = usuarios.correo`. El contador y las notificaciones recientes se comparten a todo usuario autenticado; la página de notificaciones está disponible solo para `administrador`.
Endpoints principales:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/notificaciones` | Colección completa filtrada y ordenada en el servidor, con búsqueda local y paginación en el navegador de 10 filas. |
| GET | `/notificaciones/count` | Contador y notificaciones recientes. |
| POST | `/notificaciones/{id}/leer` | Marcar una notificación como leída. |
| POST | `/notificaciones/leer-todas` | Marcar todas como leídas. |
---
## Auditoría
El trait `App\Traits\LogsAuditoria` registra automáticamente operaciones de creación, actualización y eliminación en `auditorias`.
- Guarda acción, tabla, identificador, valores anterior y nuevo en JSON, usuario e IP.
- Se utiliza en los modelos de dominio de áreas, amenazas, controles, perfiles, permisos, recursos, riesgos, roles, tipos, usuarios y vulnerabilidades.
- Si no hay usuario autenticado, utiliza `user_id = 1` como fallback.
- El listado y los endpoints de exportación están disponibles solo para `administrador`. En la interfaz, CSV, XLSX y PDF exportan todos los registros filtrados localmente con las columnas, el orden y los valores formateados visibles en la tabla, sin controles de acciones.
---
## Backups
### Requisito para Backups
Las funciones de backup utilizan **7-Zip** para generar archivos comprimidos
con cifrado AES-256.
Instalar 7-Zip y verificar que el ejecutable esté disponible según la
configuración utilizada por el proyecto.
Por defecto el proyecto busca `C:/Program Files/7-Zip/7z.exe`. Si 7-Zip
se instaló en otra ubicación, configurar `BACKUP_7ZIP_PATH` en `.env`.
El password de cifrado (`BACKUP_PASSWORD`) debe estar definido en `.env`;
sin este valor, el comando `backup:create` rechaza la operación.
El módulo de backups está disponible únicamente para `administrador`.
- `backup:create` genera un dump de MySQL, lo comprime y lo cifra mediante 7-Zip AES-256.
- Los backups generados por el comando se registran como backups completados; los archivos subidos desde la interfaz se aceptan como ZIP con SQL y la interfaz no verifica que estén cifrados.
- La frecuencia puede configurarse como diaria, semanal o mensual desde `/backups`, incluyendo la hora (`run_time`) y el día de la semana/mes (`run_day`).
- El scheduler invoca `backup:create` cada minuto. El comando consulta `backup_settings` y solo ejecuta cuando coinciden el día y la hora configurados. La tarea `M GAP Backup Scheduler` ejecuta `php artisan schedule:run` cada minuto vía `backup-scheduler.bat` (lanzado oculto por `backup-scheduler-hidden.vbs`).
- Se conservan hasta 15 copias exitosas por defecto (`BACKUP_RETENTION` en `.env`). Al superar el límite, la copia más antigua se elimina automáticamente. La interfaz muestra un aviso antes de crear o subir una nueva copia cuando ya se alcanzó el límite.
- La interfaz permite listar, crear, subir, descargar, restaurar y eliminar backups.
- `php artisan backup:restore {backupId}` restaura un backup desde CLI e intenta crear antes un dump temporal de seguridad. Ese dump no se registra como backup persistente y la restauración continúa aunque no pueda crearse.
Rutas principales:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/backups` | Listado y configuración. |
| POST | `/backups` | Crear backup. |
| POST | `/backups/upload` | Subir backup. |
| POST | `/backups/{backup}/restore` | Restaurar backup desde la interfaz. |
| GET | `/backups/{backup}/download` | Descargar backup. |
| DELETE | `/backups/{backup}` | Eliminar backup. |
| PUT | `/backups/settings` | Actualizar configuración. |
---
## Estructura del Proyecto
```text
m-gap/
├── app/
│ ├── Console/Commands/ # RecalculateRiesgos, BackupCreateCommand, BackupRestoreCommand
│ ├── Http/Controllers/ # CRUD, gestión, dashboards y reportes
│ ├── Http/Middleware/ # HandleInertiaRequests
│ ├── Http/Requests/ # Validaciones FormRequest
│ ├── Http/Resources/ # Resources API
│ ├── Models/ # Modelos Eloquent
│ ├── Services/ # Servicios como NotificacionService
│ ├── Support/ # RiskCalculator, HistoricalPeriod, AreaResponsibilityHistory, BackupRetention
│ └── Traits/ # LogsAuditoria
├── config/permission.php # Configuración de Spatie y tablas auth_*
├── database/
│ ├── migrations/ # Incluye 2026_08_20_000002_create_seeder_runs_table.php
│ └── seeders/ # DatabaseSeeder, GrcDemoSeeder, DatosDemoSeeder, RolesSistemaSeeder, DashboardMassiveSeeder y Concerns/SeedsSafely
├── resources/js/
│ ├── Components/ # Componentes reutilizables y combos
│ ├── constants/ # enums.js (ESTADOS_CONTROL, NIVELES_CONTROL)
│ ├── Layouts/ # AuthenticatedLayout
│ ├── Pages/ # Páginas Inertia
│ ├── context/ # AlertContext
│ ├── service/ # api.js y fetchers de combos
│ ├── theme/ # MGAP-Theme.js
│ └── utils/ # permissions, exportUtils, date y filtros
├── routes/
│ ├── web.php # Rutas principales
│ ├── api.php # Endpoints JSON auxiliares
│ ├── auth.php # Rutas de autenticación (Breeze)
│ └── console.php # Programación de comandos
└── tests/
├── Feature/ # Tests de integración
└── Unit/ # Tests unitarios
```
### Convenciones
- Los módulos CRUD suelen utilizar `Index.jsx` para listados, `Create.jsx` para altas y `Gestionar.jsx` para fichas editables y relaciones históricas.
- Algunos módulos incluyen también `Edit.jsx`; los módulos de tipos comparten `Generic/Gestionar.jsx` cuando corresponde.
- Las relaciones many-to-many utilizan pivots con fechas históricas (`fecha_inicio`, `fecha_identificacion` y `fecha_fin`).
- Las relaciones históricas se finalizan conservando el registro del pivot, en lugar de eliminarlo.
- El índice de áreas muestra un único responsable vigente. Una responsabilidad está vigente cuando `fecha_inicio <= ahora` y `fecha_fin` es nula o posterior a ahora; si existen períodos históricos superpuestos, el vigente con la `fecha_inicio` más reciente es el canónico.
- Las entidades con historial siguen una política de preservación: se rechaza la eliminación cuando existen registros asociados (protegido por constraints FK). No se utilizan SoftDeletes ni se marca la entidad como inactiva.
- Los formularios de alta no incluyen campos de riesgo inherente o residual; esos valores se calculan en backend.
---
## Rutas
Las rutas web se agrupan por autenticación y rol. Los módulos de lectura suelen estar disponibles para `administrador` y `visor`; las operaciones de escritura, backups y seguridad requieren `administrador`. Auditorías y notificaciones son exclusivas de `administrador`.
### Módulos de Dominio
Los siguientes módulos comparten el patrón general: **áreas, amenazas, controles, vulnerabilidades, permisos, roles, perfiles, usuarios y recursos**.
Operaciones de lectura:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/{modulo}` | Colección completa filtrada y ordenada en el servidor, con búsqueda local y paginación en el navegador de 10 filas. |
| GET | `/{modulo}/export` | Exportación CSV del servidor en los módulos que exponen este endpoint; el CSV local exporta todos los registros filtrados con las columnas y el formato de la tabla visible, sin acciones. |
| GET | `/{modulo}/{entidad}/gestionar` | Ficha de la entidad y relaciones históricas. |
Operaciones de escritura, solo para administradores:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/{modulo}/create` | Formulario de alta. |
| POST | `/{modulo}` | Crear entidad. |
| PUT / DELETE | `/{modulo}/{entidad}` | Actualizar o eliminar entidad, cuando aplica. |
| PUT | `/{modulo}/{entidad}/campo` | Actualizar un campo individual. |
| POST | `/{modulo}/{entidad}/{relacion}` | Asociar una relación histórica. |
| PUT | `/{modulo}/{entidad}/{relacion}/{pivotId}` | Actualizar una asignación. |
| DELETE | `/{modulo}/{entidad}/{relacion}/{pivotId}` | Finalizar una asignación conservando el historial. |
Relaciones gestionadas por módulo:
| Módulo | Relaciones |
|--------|------------|
| `areas` | `usuarios`, `recursos` |
| `amenazas` | `vulnerabilidades` |
| `controles` | `riesgos` |
| `vulnerabilidades` | `amenazas`, `recursos` |
| `permisos` | `perfiles` |
| `roles` | `usuarios`, `perfiles` |
| `perfiles` | `roles`, `permisos`, `recursos` |
| `usuarios` | `areas`, `roles`, `recursos` |
| `recursos` | `usuarios`, `areas`, `perfiles`, `vulnerabilidades` |
### Riesgos
Riesgos utiliza una edición específica porque sus puntajes se calculan automáticamente:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/riesgos` | Listado de riesgos. |
| GET | `/riesgos/create` | Formulario de alta. |
| POST | `/riesgos` | Crear riesgo y calcular sus puntajes. |
| GET | `/riesgos/{riesgo}/gestionar` | Ficha del riesgo y controles asociados. |
| PUT | `/riesgos/{riesgo}/campo` | Actualizar un campo individual. |
| DELETE | `/riesgos/{riesgo}` | Eliminar o preservar según las reglas del módulo. |
| POST | `/riesgos/{riesgo}/controles` | Asociar control. |
| PUT | `/riesgos/{riesgo}/controles/{pivotId}` | Actualizar asignación de control. |
| DELETE | `/riesgos/{riesgo}/controles/{pivotId}` | Finalizar asignación de control. |
Riesgos no tiene ruta `update` general ni endpoint de exportación CSV en el servidor; su listado sí exporta CSV local. La edición se realiza campo a campo.
### Parametros, auditoría y operaciones especiales
| Módulo | Rutas principales | Acceso |
|--------|------------------|--------|
| Tipos | `/tipos-usuarios`, `/tipos-recursos`, `/tipos-controles`, `/tipos-amenazas`, `/tipos-vulnerabilidades` | Solo administrador; CRUD, gestionar y campo. `tipos-vulnerabilidades` no tiene `update` general. |
| Auditorías | `/auditorias`, `/auditorias/export` | Solo administrador. |
| Notificaciones | `/notificaciones`, `/notificaciones/count`, `/notificaciones/{id}/leer`, `/notificaciones/leer-todas` | Solo administrador. |
| Catálogo | `/tablero/catalogo-activos` | Los tres roles. |
| Asignación de usuarios | `/asignar-usuario` y endpoints `store`/`detach` + `update` | Lectura para administrador y visor; escritura solo administrador. |
| Seguridad | `/seguridad/usuarios`, `PUT /seguridad/usuarios/{user}/rol` | Solo administrador. |
| Perfil | `/profile` | Usuario autenticado: consultar, actualizar o eliminar su perfil. |
### API Auxiliar
Los endpoints de API requieren `auth:sanctum` y son consumidos principalmente desde `resources/js/service/api.js`:
| Método | Ruta | Descripción |
|--------|------|-------------|
| GET | `/api/user` | Usuario autenticado. |
| GET | `/api/combos/areas` | Combo de áreas. |
| GET | `/api/combos/roles` | Combo de roles. |
| GET | `/api/combos/perfiles` | Combo de perfiles. |
| GET | `/api/combos/tipos-usuarios` | Combo de tipos de usuario. |
| GET | `/api/combos/tipos-recursos` | Combo de tipos de recurso. |
| GET | `/api/combos/tipos-controles` | Combo de tipos de control. |
| GET | `/api/combos/tipos-amenazas` | Combo de tipos de amenaza. |
| GET | `/api/combos/amenazas` | Combo de amenazas. |
| GET | `/api/combos/recursos` | Combo de recursos. |
| GET | `/api/combos/vulnerabilidades` | Combo de vulnerabilidades. |
| GET | `/api/combos/controles` | Combo de controles. |
| GET | `/api/usuarios/buscar` | Búsqueda de usuarios del dominio. |
---
*Desarrollado por Mauro Joannas y Rodrigo Legoff - Matriz de gestion para los activos y permisos (M GAP)*
@@ -0,0 +1,195 @@
<?php
namespace App\Console\Commands;
use App\Models\Backup;
use App\Support\BackupRetention;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
class BackupCreateCommand extends Command
{
protected $signature = 'backup:create {--frequency=}';
protected $description = 'Create a database backup with mysqldump and 7zip encryption';
public function handle(): int
{
$frequency = $this->option('frequency');
if ($frequency === null) {
$settings = DB::table('backup_settings')->first();
if (! $settings || ! $settings->is_active) {
$this->info('Backup scheduler is not active. Skipping.');
return self::SUCCESS;
}
$frequency = $settings->frequency;
if ($frequency === 'manual') {
$this->info('Backup frequency is manual; skipping scheduler.');
return self::SUCCESS;
}
if (! $this->shouldRun($frequency, $settings)) {
$this->info("Backup not scheduled for now (frequency: {$frequency}).");
return self::SUCCESS;
}
}
$config = config('backup');
$db = $config['database'];
$password = $config['password'];
$timestamp = now()->format('Y-m-d_His');
$sqlFile = storage_path("app/private/temp_dump_{$timestamp}.sql");
$zipFile = storage_path("app/private/backups/backup_{$timestamp}.zip");
if (empty($password)) {
$message = 'BACKUP_PASSWORD no está configurada en el .env. Agregá BACKUP_PASSWORD=<clave> y volvé a intentar.';
Backup::create([
'filename' => "backup_{$timestamp}.zip",
'status' => 'failed',
'frequency' => $frequency,
'created_by' => auth()->id() ?? 1,
'started_at' => now(),
'completed_at' => now(),
'error_message' => $message,
]);
$this->error($message);
return self::FAILURE;
}
$backupDir = storage_path('app/private/backups');
if (! is_dir($backupDir)) {
mkdir($backupDir, 0755, true);
}
$backup = Backup::create([
'filename' => "backup_{$timestamp}.zip",
'status' => 'pending',
'frequency' => $frequency,
'created_by' => auth()->id() ?? 1,
'started_at' => now(),
]);
$this->info("Starting backup: backup_{$timestamp}.zip");
try {
$this->info('Running mysqldump...');
$dumpCommand = sprintf(
'%s --host=%s --port=%s --user=%s --password=%s --single-transaction --routines --triggers --result-file=%s %s 2>&1',
escapeshellarg($config['mysqldump_path']),
escapeshellarg($db['host']),
escapeshellarg((string) $db['port']),
escapeshellarg($db['username']),
escapeshellarg($db['password']),
escapeshellarg($sqlFile),
escapeshellarg($db['database'])
);
$output = [];
$exitCode = 0;
exec($dumpCommand, $output, $exitCode);
if ($exitCode !== 0) {
throw new \RuntimeException('mysqldump failed: '.implode("\n", $output));
}
if (! file_exists($sqlFile) || filesize($sqlFile) === 0) {
throw new \RuntimeException('SQL dump file is empty or was not created.');
}
$originalSize = filesize($sqlFile);
$this->info('Dump created: '.number_format($originalSize).' bytes');
$this->info('Compressing and encrypting with 7-Zip...');
$zipCommand = sprintf(
'%s a -tzip -mem=AES256 -p%s -y %s %s 2>&1',
escapeshellarg($config['seven_zip_path']),
escapeshellarg($password),
escapeshellarg($zipFile),
escapeshellarg($sqlFile)
);
exec($zipCommand, $output, $exitCode);
if ($exitCode !== 0) {
throw new \RuntimeException('7-Zip failed: '.implode("\n", $output));
}
if (! file_exists($zipFile)) {
throw new \RuntimeException('ZIP file was not created.');
}
$compressedSize = filesize($zipFile);
$backup->update([
'status' => 'completed',
'original_size' => $originalSize,
'compressed_size' => $compressedSize,
'completed_at' => now(),
]);
$this->info("Backup completed: {$backup->filename} ({$compressedSize} bytes)");
$pruned = BackupRetention::prune($config['retention']);
if ($pruned > 0) {
$this->info("Pruned {$pruned} old backup(s).");
}
if ($frequency !== 'manual') {
DB::table('backup_settings')->update(['last_run_at' => now()]);
}
@unlink($sqlFile);
return self::SUCCESS;
} catch (\Throwable $e) {
$backup->update([
'status' => 'failed',
'error_message' => $e->getMessage(),
'completed_at' => now(),
]);
$this->error("Backup failed: {$e->getMessage()}");
@unlink($sqlFile);
@unlink($zipFile);
return self::FAILURE;
}
}
private function shouldRun(string $frequency, object $settings): bool
{
$now = now();
$runTime = $settings->run_time ? substr($settings->run_time, 0, 5) : '02:00';
if ($now->format('H:i') !== $runTime) {
return false;
}
if (isset($settings->last_run_at) && $settings->last_run_at) {
$lastRun = \Carbon\Carbon::parse($settings->last_run_at);
if ($lastRun->toDateString() === $now->toDateString()) {
return false;
}
}
$runDay = isset($settings->run_day) ? (int) $settings->run_day : null;
return match ($frequency) {
'daily' => true,
'weekly' => $runDay !== null ? $now->dayOfWeek === $runDay : $now->isSunday(),
'monthly' => $runDay !== null ? $now->day === $runDay : $now->day === 1,
default => false,
};
}
}
@@ -0,0 +1,161 @@
<?php
namespace App\Console\Commands;
use App\Models\Backup;
use Illuminate\Console\Command;
class BackupRestoreCommand extends Command
{
protected $signature = 'backup:restore {backupId}';
protected $description = 'Restore a database backup (CLI only)';
public function handle(): int
{
$backupId = $this->argument('backupId');
$backup = Backup::find($backupId);
if (! $backup || $backup->status !== 'completed') {
$this->error("Backup #{$backupId} not found or not completed.");
return self::FAILURE;
}
$config = config('backup');
$db = $config['database'];
$password = $config['password'];
$zipPath = storage_path("app/private/backups/{$backup->filename}");
if (! file_exists($zipPath)) {
$this->error("Backup file not found: {$zipPath}");
return self::FAILURE;
}
if (empty($password)) {
$this->error('BACKUP_PASSWORD no está configurada en el .env. Agregá BACKUP_PASSWORD=<clave> y volvé a intentar.');
return self::FAILURE;
}
$tempDir = storage_path('app/private/temp_restore_'.now()->format('Y-m-d_His'));
mkdir($tempDir, 0755, true);
try {
$this->info('Creating safety backup of current database...');
$safetyFile = $tempDir.'/pre_restore.sql';
$dumpCommand = sprintf(
'%s --host=%s --port=%s --user=%s --password=%s --single-transaction --result-file=%s %s 2>&1',
escapeshellarg($config['mysqldump_path']),
escapeshellarg($db['host']),
escapeshellarg((string) $db['port']),
escapeshellarg($db['username']),
escapeshellarg($db['password']),
escapeshellarg($safetyFile),
escapeshellarg($db['database'])
);
exec($dumpCommand, $output, $exitCode);
if ($exitCode !== 0) {
$this->warn('Warning: Could not create safety backup. Continuing anyway.');
}
$this->info('Decrypting backup...');
$extractCommand = sprintf(
'%s x -p%s -o%s -y %s 2>&1',
escapeshellarg($config['seven_zip_path']),
escapeshellarg($password),
escapeshellarg($tempDir),
escapeshellarg($zipPath)
);
exec($extractCommand, $output, $exitCode);
if ($exitCode !== 0) {
throw new \RuntimeException('7-Zip extraction failed: '.implode("\n", $output));
}
$sqlFiles = glob($tempDir.'/*.sql');
if (empty($sqlFiles)) {
throw new \RuntimeException('No SQL file found in extracted backup.');
}
$sqlFile = $sqlFiles[0];
$this->info('Dropping all tables...');
$config2 = config('backup');
$db2 = $config2['database'];
\DB::unprepared('SET FOREIGN_KEY_CHECKS = 0');
$tables = \DB::select('SHOW TABLES');
$dbName = \DB::getDatabaseName();
$tableKey = "Tables_in_{$dbName}";
foreach ($tables as $table) {
$tableName = $table->$tableKey;
\DB::statement("DROP TABLE IF EXISTS `{$tableName}`");
}
\DB::unprepared('SET FOREIGN_KEY_CHECKS = 1');
$this->info('Restoring database...');
$passwordArg = $db['password'] !== '' ? '--password='.escapeshellarg($db['password']) : '--password=""';
$restoreCommand = sprintf(
'%s --host=%s --port=%s --user=%s %s %s',
escapeshellarg($config['mysql_path']),
escapeshellarg($db['host']),
escapeshellarg((string) $db['port']),
escapeshellarg($db['username']),
$passwordArg,
escapeshellarg($db['database'])
);
$descriptors = [
0 => ['pipe', 'r'],
1 => ['pipe', 'w'],
2 => ['pipe', 'w'],
];
$process = proc_open($restoreCommand, $descriptors, $pipes);
if (! is_resource($process)) {
throw new \RuntimeException('No se pudo iniciar mysql.exe para la restauración.');
}
fwrite($pipes[0], file_get_contents($sqlFile));
fclose($pipes[0]);
$stdout = stream_get_contents($pipes[1]);
$stderr = stream_get_contents($pipes[2]);
fclose($pipes[1]);
fclose($pipes[2]);
$exitCode = proc_close($process);
if ($exitCode !== 0) {
throw new \RuntimeException('MySQL restore failed: '.($stderr ?: $stdout));
}
$this->info("Database restored successfully from: {$backup->filename}");
$this->cleanupTempDir($tempDir);
return self::SUCCESS;
} catch (\Throwable $e) {
$this->error("Restore failed: {$e->getMessage()}");
$this->cleanupTempDir($tempDir);
return self::FAILURE;
}
}
private function cleanupTempDir(string $dir): void
{
$files = glob($dir.'/*');
foreach ($files as $file) {
if (is_file($file)) {
@unlink($file);
}
}
@rmdir($dir);
}
}
@@ -0,0 +1,22 @@
<?php
namespace App\Console\Commands;
use App\Support\RiskCalculator;
use Illuminate\Console\Command;
class RecalculateRiesgos extends Command
{
protected $signature = 'riesgos:recalcular';
protected $description = 'Recalculate ISO 27001 risk scores for all active riesgos';
public function handle(): int
{
$count = RiskCalculator::recalculateAll();
$this->info("Recalculated risk scores for {$count} riesgos.");
return Command::SUCCESS;
}
}
+132
View File
@@ -0,0 +1,132 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\TipoAmenaza;
use App\Support\RiskCalculator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class AmenazaController extends Controller
{
private function applyAmenazaFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), [
'nombre', 'descripcion', 'nivel_de_amenaza', 'fuente', 'origen',
]);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
if ($request->filled('tipo_amenaza_id')) {
$tipoId = $request->input('tipo_amenaza_id');
$query->whereHas('tiposAmenazas', function (Builder $query) use ($tipoId): void {
$query->where('tipos_amenazas.id', $tipoId);
});
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'tipo_amenaza_id'];
$query = Amenaza::with('tiposAmenazas');
$this->applyAmenazaFilters($query, $request);
return Inertia::render('Amenazas/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'tiposAmenazas' => TipoAmenaza::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
],
]);
}
public function export(Request $request)
{
$query = Amenaza::with('tiposAmenazas');
$this->applyAmenazaFilters($query, $request);
return $this->streamCsv(
'amenazas_'.now()->format('Ymd_His').'.csv',
['ID', 'Nombre', 'Descripción', 'Nivel', 'Fuente', 'Origen', 'Fecha Alta', 'Fecha Baja'],
$query->get(),
fn ($item) => [
$item->id,
$item->nombre,
$item->descripcion,
$item->nivel_de_amenaza,
$item->fuente,
$item->origen,
$item->fecha_alta,
$item->fecha_baja,
],
);
}
public function create()
{
return Inertia::render('Amenazas/Create', [
'tipos_amenazas' => TipoAmenaza::query()->orderBy('nombre')->get(),
]);
}
public function store(Request $request)
{
$validated = $this->validateAmenaza($request);
$tipoId = $validated['tipo_amenaza_id'];
unset($validated['tipo_amenaza_id']);
$amenaza = Amenaza::create($validated);
$amenaza->tiposAmenazas()->attach($tipoId);
return redirect()->route('amenazas.index')->with('success', 'Amenaza creada exitosamente.');
}
public function edit(Amenaza $amenaza)
{
return redirect()->route('amenazas.gestionar', $amenaza);
}
public function update(Request $request, Amenaza $amenaza)
{
$validated = $this->validateAmenaza($request);
$tipoId = $validated['tipo_amenaza_id'];
unset($validated['tipo_amenaza_id']);
$amenaza->update($validated);
$amenaza->tiposAmenazas()->sync([$tipoId]);
RiskCalculator::recalculateForAmenaza($amenaza->id);
return redirect()->route('amenazas.index')->with('success', 'Amenaza actualizada exitosamente.');
}
public function destroy(Amenaza $amenaza)
{
$this->deletePreservingHistory($amenaza);
return redirect()->route('amenazas.index')->with('success', 'Amenaza eliminada exitosamente.');
}
private function validateAmenaza(Request $request): array
{
return $request->validate([
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'nivel_de_amenaza' => ['nullable', 'string', 'in:Bajo,Medio,Alto,Crítico'],
'fuente' => ['nullable', 'string', 'in:Interna,Externa'],
'origen' => ['nullable', Rule::in(['Humana', 'Natural', 'Ambiental', 'Tecnológica'])],
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
'tipo_amenaza_id' => ['required', 'exists:tipos_amenazas,id'],
]);
}
}
@@ -0,0 +1,167 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\TipoAmenaza;
use App\Models\Vulnerabilidad;
use App\Support\HistoricalPeriod;
use App\Support\RiskCalculator;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class AmenazaGestionController extends Controller
{
public function show(Amenaza $amenaza)
{
return Inertia::render('Amenazas/Gestionar', [
'amenaza' => $amenaza->load(['tiposAmenazas', 'vulnerabilidades', 'riesgos.recurso', 'riesgos.vulnerabilidad']),
'tiposAmenazas' => TipoAmenaza::query()->orderBy('nombre')->get(),
'vulnerabilidades' => Vulnerabilidad::query()->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Amenaza $amenaza)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'descripcion', 'nivel_de_amenaza', 'fuente', 'origen', 'fecha_alta', 'fecha_baja', 'tipo_amenaza_id'])],
'value' => ['nullable'],
]);
if ($validated['field'] === 'tipo_amenaza_id') {
$tipoId = validator(
['value' => $validated['value']],
['value' => ['required', 'exists:tipos_amenazas,id']],
)->validate()['value'];
$amenaza->tiposAmenazas()->sync([$tipoId]);
return back()->with('success', 'Dato actualizado correctamente.');
}
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'nivel_de_amenaza' => ['nullable', 'string', 'in:Bajo,Medio,Alto,Crítico'],
'fuente' => ['nullable', 'string', 'in:Interna,Externa'],
'origen' => ['nullable', Rule::in(['Humana', 'Natural', 'Ambiental', 'Tecnológica'])],
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date'],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
validator([
'fecha_alta' => $validated['field'] === 'fecha_alta' ? $value : $amenaza->fecha_alta,
'fecha_baja' => $validated['field'] === 'fecha_baja' ? $value : $amenaza->fecha_baja,
], [
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
])->validate();
$amenaza->update([$validated['field'] => $value]);
if ($validated['field'] === 'nivel_de_amenaza') {
RiskCalculator::recalculateForAmenaza($amenaza->id);
}
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachVulnerabilidad(Request $request, Amenaza $amenaza)
{
$validated = $request->validate([
'vulnerabilidad_id' => ['required', 'exists:vulnerabilidades,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('amenazas_vulnerabilidades')
->where('amenazas_id', $amenaza->id)
->where('vulnerabilidades_id', $validated['vulnerabilidad_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para esta vulnerabilidad.',
]);
}
}
$amenaza->vulnerabilidades()->attach($validated['vulnerabilidad_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Vulnerabilidad asociada correctamente.');
}
public function detachVulnerabilidad(Amenaza $amenaza, $pivotId)
{
DB::table('amenazas_vulnerabilidades')->where('amenazas_id', $amenaza->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación eliminada correctamente.');
}
public function updateVulnerabilidadPivot(Request $request, Amenaza $amenaza, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('amenazas_vulnerabilidades')
->where('amenazas_id', $amenaza->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('amenazas_vulnerabilidades')
->where('amenazas_id', $amenaza->id)
->where('vulnerabilidades_id', $registroActual->vulnerabilidades_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente.',
]);
}
}
DB::table('amenazas_vulnerabilidades')
->where('amenazas_id', $amenaza->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
}
+164
View File
@@ -0,0 +1,164 @@
<?php
namespace App\Http\Controllers;
use App\Models\Area;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Inertia\Inertia;
class AreaController extends Controller
{
private function applyAreaFilters(Builder $query, Request $request): Builder
{
foreach (['nombre', 'correo'] as $field) {
if ($request->filled($field)) {
$query->where($field, 'like', '%'.trim((string) $request->input($field)).'%');
}
}
if ($request->input('activo') !== null && $request->input('activo') !== '') {
$query->where('activo', $request->boolean('activo'));
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'responsable', 'correo', 'activo'];
$query = Area::with('usuarios');
$this->applyAreaFilters($query, $request);
$items = $this->filterByVisibleValues($query->orderBy('id')->get(), $request);
$items->each(function (Area $area): void {
$responsable = $area->responsableActualUsuario();
$area->setAttribute('responsable_actual', $responsable ? [
'id' => $responsable->id,
'nombre_completo' => trim("{$responsable->nombre} {$responsable->apellido}"),
] : null);
$area->makeHidden('usuarios');
});
return Inertia::render('Areas/Index', [
'items' => $items,
'filters' => $request->only($filterKeys),
'filterOptions' => [
'activos' => [
['value' => '1', 'label' => 'Sí'],
['value' => '0', 'label' => 'No'],
],
],
]);
}
public function export(Request $request)
{
$query = Area::with('usuarios');
$this->applyAreaFilters($query, $request);
$items = $this->filterByVisibleValues($query->get(), $request);
return $this->streamCsv(
'areas_'.now()->format('Ymd_His').'.csv',
['Nombre', 'Responsable', 'Correo', 'Teléfono', 'Fecha Alta', 'Fecha Baja', 'Estado'],
$items,
fn ($item) => [
$item->nombre,
$item->responsable ?? 'Sin responsable',
$item->correo ?: '-',
$item->telefono ?: '-',
$item->fecha_alta?->format('j/n/Y') ?: '-',
$item->fecha_baja?->format('j/n/Y') ?: '-',
$item->activo ? 'Activa' : 'Inactiva',
],
);
}
public function create()
{
return Inertia::render('Areas/Create');
}
public function store(Request $request)
{
Area::create($this->validateArea($request));
return redirect()->route('areas.index')->with('success', 'Área creada exitosamente.');
}
public function edit(Area $area)
{
return Inertia::render('Areas/Edit', ['item' => $area]);
}
public function update(Request $request, Area $area)
{
$area->update($this->validateArea($request));
return redirect()->route('areas.index')->with('success', 'Área actualizada exitosamente.');
}
public function destroy(Area $area)
{
$this->deletePreservingHistory($area);
return redirect()->route('areas.index')->with('success', 'Área eliminada exitosamente.');
}
private function validateArea(Request $request): array
{
return $request->validate([
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'correo' => ['nullable', 'email', 'max:35'],
'direccion' => ['nullable', 'string', 'max:35'],
'telefono' => ['nullable', 'string', 'regex:/^[0-9]*$/', 'max:35'],
'motivo_alta' => ['nullable', 'string', 'max:35'],
'activo' => ['nullable', 'boolean'],
'fecha_alta' => ['nullable', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
]);
}
private function filterByVisibleValues(Collection $areas, Request $request): Collection
{
if ($request->filled('search')) {
$search = Str::lower(Str::ascii(trim((string) $request->input('search'))));
if (in_array($search, ['activo', 'activa', 'inactivo', 'inactiva'], true)) {
$active = in_array($search, ['activo', 'activa'], true);
$areas = $areas->filter(fn (Area $area): bool => $area->activo === $active);
} else {
$areas = $areas->filter(function (Area $area) use ($search): bool {
$visibleValues = implode(' ', [
$area->nombre,
$area->responsable ?? 'Sin responsable',
$area->correo ?: '-',
$area->telefono ?: '-',
$area->fecha_alta?->format('j/n/Y') ?: '-',
$area->fecha_baja?->format('j/n/Y') ?: '-',
$area->activo ? 'Activa' : 'Inactiva',
]);
return Str::contains(Str::lower(Str::ascii($visibleValues)), $search);
});
}
}
if ($request->filled('responsable')) {
$terms = preg_split('/\s+/', trim((string) $request->input('responsable')), -1, PREG_SPLIT_NO_EMPTY);
$areas = $areas->filter(function (Area $area) use ($terms): bool {
$responsable = Str::lower(Str::ascii($area->responsable ?? ''));
return collect($terms)->every(
fn (string $term): bool => Str::contains($responsable, Str::lower(Str::ascii($term)))
);
});
}
return $areas->values();
}
}
@@ -0,0 +1,296 @@
<?php
namespace App\Http\Controllers;
use App\Models\Area;
use App\Models\Recurso;
use App\Models\Usuario;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
class AreaGestionController extends Controller
{
public function show(Area $area)
{
return Inertia::render('Areas/Gestionar', [
'area' => $area->load(['usuarios', 'recursos.tipoRecurso']),
'usuarios' => Usuario::query()->where('activo', true)->orderBy('nombre')->orderBy('apellido')->get(),
'recursos' => Recurso::query()->with('tipoRecurso')->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Area $area)
{
$validated = $request->validate([
'field' => ['required', Rule::in([
'nombre', 'descripcion', 'correo', 'direccion', 'telefono',
'motivo_alta', 'activo', 'fecha_alta', 'fecha_baja',
])],
'value' => ['nullable'],
]);
if ($validated['field'] === 'activo') {
$validated['value'] = (int) $validated['value'];
}
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'correo' => ['nullable', 'email', 'max:35'],
'direccion' => ['nullable', 'string', 'max:35'],
'telefono' => ['nullable', 'string', 'regex:/^[0-9]*$/', 'max:35'],
'motivo_alta' => ['nullable', 'string', 'max:35'],
'activo' => ['required', 'boolean'],
];
if (isset($rules[$validated['field']])) {
validator(['value' => $validated['value']], ['value' => $rules[$validated['field']]])->validate();
}
$fechas = [
'fecha_alta' => $validated['field'] === 'fecha_alta' ? $validated['value'] : $area->fecha_alta,
'fecha_baja' => $validated['field'] === 'fecha_baja' ? $validated['value'] : $area->fecha_baja,
];
$validator = Validator::make($fechas, [
'fecha_alta' => ['nullable', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
], [
'fecha_baja.after_or_equal' => 'La fecha de baja no puede ser anterior a la fecha de alta.',
]);
if ($validator->fails()) {
throw ValidationException::withMessages(['value' => $validator->errors()->first()]);
}
$area->update([$validated['field'] => $validated['value']]);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachUsuario(Request $request, Area $area)
{
$validated = $request->validate([
'usuario_id' => ['required', 'exists:usuarios,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'responsable' => ['required', 'boolean'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($area, $validated) {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$this->ensureNoOverlap(
$area,
(int) $validated['usuario_id'],
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
);
$area->usuarios()->attach($validated['usuario_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'responsable' => $validated['responsable'],
]);
});
return back()->with('success', 'Usuario asignado al histórico correctamente.');
}
public function updateUsuarioPivot(Request $request, Area $area, int $pivotId)
{
$validated = $request->validate([
'responsable' => ['required', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$pivot = DB::table('area_usuario')
->where('area_id', $area->id)
->where('id', $pivotId)
->firstOrFail();
if ((bool) $pivot->responsable && (
! $validated['responsable']
|| Carbon::parse($pivot->fecha_inicio)->toDateString() !== Carbon::parse($validated['fecha_inicio'])->toDateString()
)) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Un período de responsabilidad no puede reprogramarse. Finalícelo y cree uno nuevo.',
]);
}
DB::transaction(function () use ($area, $pivot, $pivotId, $validated) {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$this->ensureNoOverlap(
$area,
(int) $pivot->usuario_id,
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
$pivotId,
);
DB::table('area_usuario')
->where('area_id', $area->id)
->where('id', $pivotId)
->update([
...$validated,
'updated_at' => now(),
]);
});
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachUsuario(Area $area, int $pivotId)
{
DB::table('area_usuario')->where('area_id', $area->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación eliminada correctamente.');
}
public function attachRecurso(Request $request, Area $area)
{
$validated = $request->validate([
'recurso_id' => ['required', 'exists:recursos,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($area, $validated): void {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$this->ensureNoRecursoOverlap(
$area,
(int) $validated['recurso_id'],
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
);
$area->recursos()->attach($validated['recurso_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
]);
});
return back()->with('success', 'Recurso asociado correctamente.');
}
public function updateRecursoPivot(Request $request, Area $area, int $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($area, $pivotId, $validated): void {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$pivot = DB::table('area_recurso')
->where('area_id', $area->id)
->where('id', $pivotId)
->firstOrFail();
$this->ensureNoRecursoOverlap(
$area,
(int) $pivot->recurso_id,
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
$pivotId,
);
DB::table('area_recurso')
->where('area_id', $area->id)
->where('id', $pivotId)
->update([...$validated, 'updated_at' => now()]);
});
return back()->with('success', 'Asignación de recurso actualizada correctamente.');
}
public function detachRecurso(Area $area, int $pivotId)
{
DB::table('area_recurso')->where('area_id', $area->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de recurso eliminada correctamente.');
}
private function ensureNoOverlap(
Area $area,
int $usuarioId,
string $fechaInicio,
?string $fechaFin,
?int $exceptPivotId = null,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('area_usuario')
->where('area_id', $area->id)
->where('usuario_id', $usuarioId);
if ($exceptPivotId !== null) {
$query->where('id', '!=', $exceptPivotId);
}
foreach ($query->get() as $otro) {
if (! $otro->fecha_inicio) {
continue;
}
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeQueTermineElOtro = $otroFin === null || $inicio->lte($otroFin);
$terminaDespuesDeQueEmpieceElOtro = $fin === null || $fin->gte($otroInicio);
if ($empiezaAntesDeQueTermineElOtro && $terminaDespuesDeQueEmpieceElOtro) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw ValidationException::withMessages([
'fecha_inicio' => "El período ingresado se superpone con un registro histórico existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
}
private function ensureNoRecursoOverlap(
Area $area,
int $recursoId,
string $fechaInicio,
?string $fechaFin,
?int $exceptPivotId = null,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('area_recurso')
->where('area_id', $area->id)
->where('recurso_id', $recursoId);
if ($exceptPivotId !== null) {
$query->where('id', '!=', $exceptPivotId);
}
foreach ($query->get() as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null || $inicio->lte($otroFin)) && ($fin === null || $fin->gte($otroInicio))) {
throw ValidationException::withMessages([
'fecha_inicio' => 'El período se superpone con otra asignación del recurso al área.',
]);
}
}
}
}
@@ -0,0 +1,169 @@
<?php
namespace App\Http\Controllers;
use App\Models\Recurso;
use App\Models\Usuario;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
class AsignarUsuarioController extends Controller
{
public function index()
{
$recursos = Recurso::with([
'usuarios' => fn ($query) => $query
->wherePivot('activo', true),
'tipoRecurso',
])->get();
$usuarios = Usuario::where('activo', 1)->get();
return Inertia::render('AsignarUsuario/Index', [
'recursos' => $recursos,
'usuarios' => $usuarios,
]);
}
public function store(Request $request)
{
$validated = $request->validate([
'recurso_id' => ['required', 'exists:recursos,id'],
'usuario_id' => ['required', 'exists:usuarios,id'],
'duenio' => ['nullable', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$recurso = Recurso::findOrFail($validated['recurso_id']);
DB::transaction(function () use ($recurso, $validated, $request): void {
Recurso::query()->whereKey($recurso->id)->lockForUpdate()->firstOrFail();
$this->ensureNoOverlap(
$recurso,
(int) $validated['usuario_id'],
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
);
$recurso->usuarios()->attach($validated['usuario_id'], [
'activo' => true,
'duenio' => $request->boolean('duenio'),
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
});
return back()->with('success', 'Usuario asignado correctamente.');
}
public function destroy(Request $request)
{
$request->validate([
'recurso_id' => 'required|exists:recursos,id',
'usuario_id' => 'required|exists:usuarios,id',
]);
$registro = DB::table('recurso_usuario')
->where('recurso_id', $request->integer('recurso_id'))
->where('usuario_id', $request->integer('usuario_id'))
->where('activo', true)
->orderByDesc('id')
->first();
if ($registro) {
$now = now();
$start = $registro->fecha_inicio ? Carbon::parse($registro->fecha_inicio) : $now;
$closedAt = $start->gt($now) ? $start : $now;
DB::table('recurso_usuario')->where('id', $registro->id)->update([
'fecha_fin' => $closedAt,
'activo' => false,
'updated_at' => $now,
]);
}
return redirect()->back()->with('success', 'Asignación finalizada correctamente.');
}
public function update(Request $request, string $pivotId)
{
$validated = $request->validate([
'duenio' => ['required', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('recurso_usuario')->where('id', $pivotId)->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recurso_usuario')
->where('recurso_id', $registroActual->recurso_id)
->where('usuario_id', $registroActual->usuario_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeQueTermineElOtro = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespuesDeQueEmpieceElOtro = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntesDeQueTermineElOtro && $terminaDespuesDeQueEmpieceElOtro) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con otro registro existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
DB::table('recurso_usuario')->where('id', $pivotId)->update([
'duenio' => $validated['duenio'],
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
private function ensureNoOverlap(
Recurso $recurso,
int $usuarioId,
string $fechaInicio,
?string $fechaFin,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('recurso_usuario')
->where('recurso_id', $recurso->id)
->where('usuario_id', $usuarioId)
->where('activo', true);
foreach ($query->get() as $otro) {
if (! $otro->fecha_inicio) {
continue;
}
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null || $inicio->lte($otroFin)) && ($fin === null || $fin->gte($otroInicio))) {
throw ValidationException::withMessages([
'fecha_inicio' => 'El período se superpone con otra asignación del usuario al recurso.',
]);
}
}
}
}
@@ -0,0 +1,137 @@
<?php
namespace App\Http\Controllers;
use App\Models\Auditoria;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class AuditoriaController extends Controller
{
private function applyAuditoriaFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['tabla', 'accion']);
if ($request->filled('usuario')) {
$usuario = trim((string) $request->input('usuario'));
$query->whereHas('user', function (Builder $query) use ($usuario): void {
$query->where(function (Builder $query) use ($usuario): void {
$query->where('name', 'like', "%{$usuario}%")
->orWhere('email', 'like', "%{$usuario}%");
});
});
}
if ($request->filled('accion')) {
$query->where('accion', $request->input('accion'));
}
if ($request->filled('tabla')) {
$query->where('tabla', $request->input('tabla'));
}
if ($request->filled('campo_id')) {
$query->where('campo_id', $request->input('campo_id'));
}
if ($request->filled('fecha_desde')) {
$query->whereDate('created_at', '>=', $request->input('fecha_desde'));
}
if ($request->filled('fecha_hasta')) {
$query->whereDate('created_at', '<=', $request->input('fecha_hasta'));
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'usuario', 'accion', 'tabla', 'campo_id', 'fecha_desde', 'fecha_hasta'];
$query = Auditoria::with('user');
$this->applyAuditoriaFilters($query, $request);
$items = $query->orderByDesc('created_at')->orderByDesc('id')->get()->map(function (Auditoria $auditoria): Auditoria {
$auditoria->nombre_entidad = 'ID: '.$auditoria->campo_id;
$campos = [];
if ($auditoria->valor_nuevo) {
$data = json_decode($auditoria->valor_nuevo, true);
if (is_array($data)) {
$campos = array_keys($data);
}
}
$auditoria->campos_modificados = implode(', ', $campos);
return $auditoria;
});
return Inertia::render('Auditorias/Index', [
'items' => $items,
'filters' => $request->only($filterKeys),
'filterOptions' => [
'usuarios' => User::query()->select('name as value', 'name as label')->orderBy('name')->get(),
'acciones' => Auditoria::query()
->select('accion as value', 'accion as label')
->distinct()
->orderBy('accion')
->get(),
'tablas' => Auditoria::query()
->select('tabla as value', 'tabla as label')
->distinct()
->orderBy('tabla')
->get(),
],
]);
}
public function exportData(Request $request)
{
$query = Auditoria::with('user');
$this->applyAuditoriaFilters($query, $request);
$items = $query->orderByDesc('created_at')->orderByDesc('id')->get()
->map(function (Auditoria $auditoria): array {
$campos = [];
if ($auditoria->valor_nuevo) {
$data = json_decode($auditoria->valor_nuevo, true);
if (is_array($data)) {
$campos = array_keys($data);
}
}
return [
'id' => $auditoria->id,
'user_name' => $auditoria->user->name ?? 'N/A',
'accion' => $auditoria->accion,
'tabla' => $auditoria->tabla,
'campo_id' => $auditoria->campo_id,
'campos_modificados' => implode(', ', $campos),
'valor_anterior' => $auditoria->valor_anterior,
'valor_nuevo' => $auditoria->valor_nuevo,
'ip' => $auditoria->ip,
'created_at' => $auditoria->created_at,
];
});
return response()->json($items);
}
public function export(Request $request)
{
$query = Auditoria::with('user');
$this->applyAuditoriaFilters($query, $request);
$items = $query->orderByDesc('created_at')->orderByDesc('id')->get();
$fileName = 'auditorias_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Usuario', 'Accion', 'Tabla', 'ID Registro', 'IP', 'Fecha'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id,
$item->user->name ?? 'N/A',
$item->accion,
$item->tabla,
$item->campo_id,
$item->ip,
$item->created_at,
]);
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use App\Http\Requests\Auth\LoginRequest;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Route;
use Inertia\Inertia;
use Inertia\Response;
class AuthenticatedSessionController extends Controller
{
/**
* Display the login view.
*/
public function create(): Response
{
return Inertia::render('Auth/Login', [
'canResetPassword' => Route::has('password.request'),
'status' => session('status'),
]);
}
/**
* Handle an incoming authentication request.
*/
public function store(LoginRequest $request): RedirectResponse
{
$request->authenticate();
$request->session()->regenerate();
$user = Auth::user();
if ($user->hasRole('pendiente')) {
return redirect()->route('pendiente');
}
return redirect()->intended(route('dashboard', absolute: false));
}
/**
* Destroy an authenticated session.
*/
public function destroy(Request $request): RedirectResponse
{
Auth::guard('web')->logout();
$request->session()->invalidate();
$request->session()->regenerateToken();
return redirect('/');
}
}
@@ -0,0 +1,41 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Inertia\Response;
class ConfirmablePasswordController extends Controller
{
/**
* Show the confirm password view.
*/
public function show(): Response
{
return Inertia::render('Auth/ConfirmPassword');
}
/**
* Confirm the user's password.
*/
public function store(Request $request): RedirectResponse
{
if (! Auth::guard('web')->validate([
'email' => $request->user()->email,
'password' => $request->password,
])) {
throw ValidationException::withMessages([
'password' => __('auth.password'),
]);
}
$request->session()->put('auth.password_confirmed_at', time());
return redirect()->intended(route('dashboard', absolute: false));
}
}
@@ -0,0 +1,24 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
class EmailVerificationNotificationController extends Controller
{
/**
* Send a new email verification notification.
*/
public function store(Request $request): RedirectResponse
{
if ($request->user()->hasVerifiedEmail()) {
return redirect()->intended(route('dashboard', absolute: false));
}
$request->user()->sendEmailVerificationNotification();
return back()->with('status', 'verification-link-sent');
}
}
@@ -0,0 +1,22 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Inertia\Response;
class EmailVerificationPromptController extends Controller
{
/**
* Display the email verification prompt.
*/
public function __invoke(Request $request): RedirectResponse|Response
{
return $request->user()->hasVerifiedEmail()
? redirect()->intended(route('dashboard', absolute: false))
: Inertia::render('Auth/VerifyEmail', ['status' => session('status')]);
}
}
@@ -0,0 +1,63 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Auth\Events\PasswordReset;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Password;
use Illuminate\Support\Str;
use Illuminate\Validation\Rules;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Inertia\Response;
class NewPasswordController extends Controller
{
/**
* Display the password reset view.
*/
public function create(Request $request): Response
{
return Inertia::render('Auth/ResetPassword', [
'email' => $request->email,
'token' => $request->route('token'),
]);
}
/**
* Handle an incoming new password request.
*
* @throws \Illuminate\Validation\ValidationException
*/
public function store(Request $request): RedirectResponse
{
$request->validate([
'token' => 'required',
'email' => 'required|email',
'password' => ['required', 'confirmed', Rules\Password::defaults()->mixedCase()->symbols()],
]);
$status = Password::reset(
$request->only('email', 'password', 'password_confirmation', 'token'),
function ($user) use ($request) {
$user->forceFill([
'password' => Hash::make($request->password),
'remember_token' => Str::random(60),
])->save();
event(new PasswordReset($user));
}
);
if ($status == Password::PASSWORD_RESET) {
return redirect()->route('login')->with('status', __($status));
}
throw ValidationException::withMessages([
'email' => [trans($status)],
]);
}
}
@@ -0,0 +1,29 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\Rules\Password;
class PasswordController extends Controller
{
/**
* Update the user's password.
*/
public function update(Request $request): RedirectResponse
{
$validated = $request->validate([
'current_password' => ['required', 'current_password'],
'password' => ['required', Password::defaults()->mixedCase()->symbols(), 'confirmed'],
]);
$request->user()->update([
'password' => Hash::make($validated['password']),
]);
return back();
}
}
@@ -0,0 +1,48 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Password;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
use Inertia\Response;
class PasswordResetLinkController extends Controller
{
/**
* Display the password reset link request view.
*/
public function create(): Response
{
return Inertia::render('Auth/ForgotPassword', [
'status' => session('status'),
]);
}
/**
* Handle an incoming password reset link request.
*
* @throws \Illuminate\Validation\ValidationException
*/
public function store(Request $request): RedirectResponse
{
$request->validate([
'email' => 'required|email',
]);
$status = Password::sendResetLink(
$request->only('email')
);
if ($status == Password::RESET_LINK_SENT) {
return back()->with('status', __($status));
}
throw ValidationException::withMessages([
'email' => [trans($status)],
]);
}
}
@@ -0,0 +1,53 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Auth\Events\Registered;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\Rules;
use Inertia\Inertia;
use Inertia\Response;
class RegisteredUserController extends Controller
{
/**
* Display the registration view.
*/
public function create(): Response
{
return Inertia::render('Auth/Register');
}
/**
* Handle an incoming registration request.
*
* @throws \Illuminate\Validation\ValidationException
*/
public function store(Request $request): RedirectResponse
{
$request->validate([
'name' => 'required|string|max:255',
'email' => ['required', 'string', 'lowercase', 'regex:/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i', 'max:255', 'unique:'.User::class],
'password' => ['required', 'confirmed', Rules\Password::defaults()->mixedCase()->symbols()],
]);
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
]);
$user->assignRole('pendiente');
event(new Registered($user));
Auth::login($user);
return redirect()->route('pendiente');
}
}
@@ -0,0 +1,27 @@
<?php
namespace App\Http\Controllers\Auth;
use App\Http\Controllers\Controller;
use Illuminate\Auth\Events\Verified;
use Illuminate\Foundation\Auth\EmailVerificationRequest;
use Illuminate\Http\RedirectResponse;
class VerifyEmailController extends Controller
{
/**
* Mark the authenticated user's email address as verified.
*/
public function __invoke(EmailVerificationRequest $request): RedirectResponse
{
if ($request->user()->hasVerifiedEmail()) {
return redirect()->intended(route('dashboard', absolute: false).'?verified=1');
}
if ($request->user()->markEmailAsVerified()) {
event(new Verified($request->user()));
}
return redirect()->intended(route('dashboard', absolute: false).'?verified=1');
}
}
+315
View File
@@ -0,0 +1,315 @@
<?php
namespace App\Http\Controllers;
use App\Models\Backup;
use App\Support\BackupRetention;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Inertia\Inertia;
class BackupController extends Controller
{
public function index()
{
$backups = Backup::with('user')
->orderByDesc('id')
->paginate(15);
$settings = DB::table('backup_settings')->first();
$stats = [
'total' => Backup::count(),
'completed' => Backup::where('status', 'completed')->count(),
'failed' => Backup::where('status', 'failed')->count(),
'total_size' => Backup::where('status', 'completed')->sum('compressed_size'),
'last_backup' => Backup::where('status', 'completed')
->latest('id')
->value('completed_at'),
];
return Inertia::render('Backups/Index', [
'backups' => $backups,
'settings' => $settings,
'stats' => $stats,
'retention' => config('backup.retention'),
]);
}
public function store(Request $request)
{
$validated = $request->validate([
'frequency' => ['nullable', 'string', 'in:daily,weekly,monthly,manual'],
]);
$frequency = $validated['frequency'] ?? 'manual';
$exitCode = Artisan::call('backup:create', ['--frequency' => $frequency]);
$output = Artisan::output();
if ($exitCode !== 0) {
return back()->withErrors(['backup' => 'Error al crear el backup: '.$output]);
}
return back()->with('success', 'Backup creado exitosamente.');
}
public function upload(Request $request)
{
$request->validate([
'file' => 'required|file|mimes:zip|max:102400',
]);
$file = $request->file('file');
$timestamp = now()->format('Y-m-d_His');
$filename = "uploaded_{$timestamp}_".Str::uuid().'.zip';
$destination = storage_path("app/private/backups/{$filename}");
$backupDir = storage_path('app/private/backups');
if (! is_dir($backupDir)) {
mkdir($backupDir, 0755, true);
}
$file->move($backupDir, $filename);
$config = config('backup');
$listCommand = sprintf(
'%s l -ba %s 2>&1',
escapeshellarg($config['seven_zip_path']),
escapeshellarg($destination)
);
exec($listCommand, $output, $exitCode);
if ($exitCode !== 0) {
@unlink($destination);
return back()->withErrors(['file' => 'No se pudo abrir el archivo ZIP. Asegúrese de que no esté corrupto y que sea un archivo ZIP válido.']);
}
$hasSql = false;
foreach ($output as $line) {
$trimmed = trim($line);
if (strtolower(pathinfo($trimmed, PATHINFO_EXTENSION)) === 'sql') {
$hasSql = true;
break;
}
}
if (! $hasSql) {
@unlink($destination);
return back()->withErrors(['file' => 'El archivo ZIP no contiene ningún archivo .sql.']);
}
Backup::create([
'filename' => $filename,
'original_size' => 0,
'compressed_size' => filesize($destination),
'status' => 'completed',
'frequency' => 'manual',
'created_by' => auth()->id(),
'started_at' => now(),
'completed_at' => now(),
]);
BackupRetention::prune($config['retention']);
return back()->with('success', 'Backup subido exitosamente.');
}
public function restore(Request $request, Backup $backup)
{
$request->validate([
'confirmation' => 'required|in:RESTAURAR',
'understood' => 'required|accepted',
]);
if ($backup->status !== 'completed') {
return back()->withErrors(['restore' => 'Este backup no está completado.']);
}
$config = config('backup');
$db = $config['database'];
$password = $config['password'];
if (empty($password)) {
return back()->withErrors(['restore' => 'BACKUP_PASSWORD no está configurada en el .env. Agregá BACKUP_PASSWORD=<clave> y volvé a intentar.']);
}
$zipPath = storage_path("app/private/backups/{$backup->filename}");
if (! file_exists($zipPath)) {
return back()->withErrors(['restore' => 'Archivo de backup no encontrado en disco.']);
}
$tempDir = storage_path('app/private/temp_restore_'.Str::uuid());
mkdir($tempDir, 0755, true);
try {
$safetyFile = $tempDir.'/pre_restore.sql';
$dumpCommand = sprintf(
'%s --host=%s --port=%s --user=%s --password=%s --single-transaction --result-file=%s %s 2>&1',
escapeshellarg($config['mysqldump_path']),
escapeshellarg($db['host']),
escapeshellarg($db['port']),
escapeshellarg($db['username']),
escapeshellarg($db['password']),
escapeshellarg($safetyFile),
escapeshellarg($db['database'])
);
exec($dumpCommand, $output, $exitCode);
$extractCommand = sprintf(
'%s x -p%s -o%s -y %s 2>&1',
escapeshellarg($config['seven_zip_path']),
escapeshellarg($password),
escapeshellarg($tempDir),
escapeshellarg($zipPath)
);
exec($extractCommand, $output, $exitCode);
if ($exitCode !== 0) {
throw new \RuntimeException('Error al desencriptar el backup: '.implode("\n", $output));
}
$sqlFiles = glob($tempDir.'/*.sql');
if (empty($sqlFiles)) {
throw new \RuntimeException('No se encontró archivo .sql en el backup desencriptado.');
}
$sqlFile = $sqlFiles[0];
DB::unprepared('SET FOREIGN_KEY_CHECKS = 0');
$tables = DB::select('SHOW TABLES');
$dbName = DB::getDatabaseName();
$tableKey = "Tables_in_{$dbName}";
foreach ($tables as $table) {
$tableName = $table->$tableKey;
DB::statement("DROP TABLE IF EXISTS `{$tableName}`");
}
DB::unprepared('SET FOREIGN_KEY_CHECKS = 1');
$passwordArg = $db['password'] !== '' ? '--password='.escapeshellarg($db['password']) : '--password=""';
$restoreCommand = sprintf(
'%s --host=%s --port=%s --user=%s %s %s',
escapeshellarg($config['mysql_path']),
escapeshellarg($db['host']),
escapeshellarg($db['port']),
escapeshellarg($db['username']),
$passwordArg,
escapeshellarg($db['database'])
);
$descriptors = [
0 => ['pipe', 'r'],
1 => ['pipe', 'w'],
2 => ['pipe', 'w'],
];
$process = proc_open($restoreCommand, $descriptors, $pipes);
if (! is_resource($process)) {
throw new \RuntimeException('No se pudo iniciar mysql.exe para la restauración.');
}
fwrite($pipes[0], file_get_contents($sqlFile));
fclose($pipes[0]);
$stdout = stream_get_contents($pipes[1]);
$stderr = stream_get_contents($pipes[2]);
fclose($pipes[1]);
fclose($pipes[2]);
$exitCode = proc_close($process);
if ($exitCode !== 0) {
throw new \RuntimeException('Error al restaurar la base de datos: '.($stderr ?: $stdout));
}
$this->cleanupTempDir($tempDir);
return back()->with('success', "Base de datos restaurada exitosamente desde: {$backup->filename}");
} catch (\Throwable $e) {
$this->cleanupTempDir($tempDir);
return back()->withErrors(['restore' => 'Error durante la restauración: '.$e->getMessage()]);
}
}
public function download(Backup $backup)
{
if ($backup->status !== 'completed') {
return back()->withErrors(['backup' => 'Este backup no está completado.']);
}
$path = "backups/{$backup->filename}";
$fullPath = storage_path("app/private/{$path}");
if (! file_exists($fullPath)) {
return back()->withErrors(['backup' => 'Archivo de backup no encontrado en disco.']);
}
return response()->download($fullPath, $backup->filename, [
'Content-Type' => 'application/zip',
]);
}
public function destroy(Backup $backup)
{
$path = "backups/{$backup->filename}";
$fullPath = storage_path("app/private/{$path}");
if (file_exists($fullPath)) {
@unlink($fullPath);
}
$backup->delete();
return back()->with('success', 'Backup eliminado.');
}
public function updateSettings(Request $request)
{
$frequency = $request->input('frequency');
$validated = $request->validate([
'frequency' => 'required|in:daily,weekly,monthly,manual',
'is_active' => 'required|boolean',
'run_time' => match ($frequency) {
'manual' => 'nullable',
default => 'required|date_format:H:i',
},
'run_day' => match ($frequency) {
'weekly' => 'required|integer|between:0,6',
'monthly' => 'required|integer|between:1,31',
default => 'nullable|integer',
},
]);
DB::table('backup_settings')->update([
'frequency' => $validated['frequency'],
'is_active' => $validated['is_active'],
'run_time' => $validated['run_time'] ?? '02:00',
'run_day' => $validated['run_day'] ?? null,
'last_run_at' => null,
'updated_at' => now(),
]);
return back()->with('success', 'Configuración de backup actualizada.');
}
private function cleanupTempDir(string $dir): void
{
$files = glob($dir.'/*');
foreach ($files as $file) {
if (is_file($file)) {
@unlink($file);
}
}
@rmdir($dir);
}
}
+73
View File
@@ -0,0 +1,73 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\Area;
use App\Models\Control;
use App\Models\Perfil;
use App\Models\Recurso;
use App\Models\Rol;
use App\Models\TipoAmenaza;
use App\Models\TipoControl;
use App\Models\TipoRecurso;
use App\Models\TipoUsuario;
use App\Models\Vulnerabilidad;
class ComboController extends Controller
{
public function areas()
{
return response()->json(['data' => Area::select('id', 'nombre')->where('activo', true)->get()]);
}
public function roles()
{
return response()->json(['data' => Rol::select('id', 'nombre')->get()]);
}
public function perfiles()
{
return response()->json(['data' => Perfil::select('id', 'nombre')->get()]);
}
public function tiposUsuarios()
{
return response()->json(['data' => TipoUsuario::select('id', 'nombre')->get()]);
}
public function tiposRecursos()
{
return response()->json(['data' => TipoRecurso::select('id', 'nombre')->get()]);
}
public function tiposControles()
{
return response()->json(['data' => TipoControl::select('id', 'nombre')->get()]);
}
public function tiposAmenazas()
{
return response()->json(['data' => TipoAmenaza::select('id', 'nombre')->get()]);
}
public function amenazas()
{
return response()->json(['data' => Amenaza::select('id', 'nombre')->get()]);
}
public function recursos()
{
return response()->json(['data' => Recurso::select('id', 'nombre')->get()]);
}
public function vulnerabilidades()
{
return response()->json(['data' => Vulnerabilidad::select('id', 'nombre')->get()]);
}
public function controles()
{
return response()->json(['data' => Control::select('id', 'nombre')->get()]);
}
}
+228
View File
@@ -0,0 +1,228 @@
<?php
namespace App\Http\Controllers;
use App\Models\Control;
use App\Models\Riesgo;
use App\Models\TipoControl;
use App\Support\RiskCalculator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class ControlController extends Controller
{
private function applyControlFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
if ($request->filled('estado')) {
$query->where('estado', $request->input('estado'));
}
if ($request->filled('tipo_control_id')) {
$tipoId = $request->input('tipo_control_id');
$query->whereHas('tiposControles', function (Builder $q) use ($tipoId): void {
$q->where('tipos_controles.id', $tipoId)
->where('control_tipos_control.fecha_inicio', '<=', now())
->where(function (Builder $query): void {
$query->whereNull('control_tipos_control.fecha_fin')
->orWhere('control_tipos_control.fecha_fin', '>', now());
});
});
}
if ($request->filled('fecha_inicio_desde')) {
$query->whereDate('fecha_inicio', '>=', $request->input('fecha_inicio_desde'));
}
if ($request->filled('fecha_fin_hasta')) {
$query->whereDate('fecha_fin', '<=', $request->input('fecha_fin_hasta'));
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'tipo_control_id', 'estado', 'fecha_inicio_desde', 'fecha_fin_hasta'];
$query = Control::with([
'tiposControles' => fn ($query) => $query
->where('control_tipos_control.fecha_inicio', '<=', now())
->where(function ($query): void {
$query->whereNull('control_tipos_control.fecha_fin')
->orWhere('control_tipos_control.fecha_fin', '>', now());
}),
]);
$this->applyControlFilters($query, $request);
return Inertia::render('Controles/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'tiposControles' => TipoControl::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
'estados' => Control::query()
->select('estado as value', 'estado as label')
->whereNotNull('estado')
->where('estado', '<>', '')
->distinct()
->orderBy('estado')
->get(),
],
]);
}
public function export(Request $request)
{
$query = Control::query();
$this->applyControlFilters($query, $request);
$items = $query->get();
$fileName = 'controles_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Nombre', 'Descripción', 'Estado'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id,
$item->nombre,
$item->descripcion,
$item->estado,
]);
}
public function create()
{
return Inertia::render('Controles/Create', [
'tipos_controles' => TipoControl::query()->orderBy('nombre')->get(),
]);
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'estado' => 'nullable|string|in:Implementado,En revisión,Planificado',
'nivel_de_control' => 'nullable|string|in:fuerte,parcial,debil',
'tipo_control_id' => 'required|exists:tipos_controles,id',
'fecha_inicio' => 'nullable|date',
'fecha_fin' => 'nullable|date|after_or_equal:fecha_inicio',
]);
DB::transaction(function () use ($validated) {
$control = Control::create([
'nombre' => $validated['nombre'],
'descripcion' => $validated['descripcion'] ?? null,
'estado' => $validated['estado'] ?? null,
'nivel_de_control' => $validated['nivel_de_control'] ?? null,
'fecha_inicio' => $validated['fecha_inicio'] ?? null,
'fecha_fin' => $validated['fecha_fin'] ?? null,
]);
$now = now();
$control->tiposControles()->attach($validated['tipo_control_id'], [
'fecha_inicio' => $now,
'fecha_fin' => null,
'created_at' => $now,
'updated_at' => $now,
]);
});
return redirect()->route('controles.index')->with('success', 'Control creado exitosamente.');
}
public function edit(Control $control)
{
return Inertia::render('Controles/Edit', [
'control' => $control->load([
'tiposControles' => fn ($query) => $query
->where('control_tipos_control.fecha_inicio', '<=', now())
->where(function ($query): void {
$query->whereNull('control_tipos_control.fecha_fin')
->orWhere('control_tipos_control.fecha_fin', '>', now());
}),
]),
'tipos_controles' => TipoControl::query()->orderBy('nombre')->get(),
]);
}
public function update(Request $request, Control $control)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'estado' => 'nullable|string|in:Implementado,En revisión,Planificado',
'nivel_de_control' => 'nullable|string|in:fuerte,parcial,debil',
'tipo_control_id' => 'required|exists:tipos_controles,id',
'fecha_inicio' => 'nullable|date',
'fecha_fin' => 'nullable|date|after_or_equal:fecha_inicio',
]);
$oldEstado = $control->estado;
$oldNivel = $control->nivel_de_control;
DB::transaction(function () use ($control, $validated) {
$control->update([
'nombre' => $validated['nombre'],
'descripcion' => $validated['descripcion'] ?? null,
'estado' => $validated['estado'] ?? null,
'nivel_de_control' => $validated['nivel_de_control'] ?? null,
'fecha_inicio' => $validated['fecha_inicio'] ?? null,
'fecha_fin' => $validated['fecha_fin'] ?? null,
]);
$asignacionActual = DB::table('control_tipos_control')
->where('control_id', $control->id)
->whereNull('fecha_fin')
->orderByDesc('id')
->lockForUpdate()
->first();
if ($asignacionActual && (int) $asignacionActual->tipo_control_id === (int) $validated['tipo_control_id']) {
return;
}
$now = now();
if ($asignacionActual) {
DB::table('control_tipos_control')
->where('control_id', $control->id)
->where('id', $asignacionActual->id)
->update([
'fecha_fin' => $now,
'updated_at' => $now,
]);
}
$control->tiposControles()->attach($validated['tipo_control_id'], [
'fecha_inicio' => $now,
'fecha_fin' => null,
'created_at' => $now,
'updated_at' => $now,
]);
});
$control->refresh();
if ($control->estado !== $oldEstado || $control->nivel_de_control !== $oldNivel) {
$control->riesgos()->whereNull('riesgo_control.fecha_fin')->each(function (Riesgo $riesgo) {
RiskCalculator::recalculate($riesgo);
});
}
return redirect()->route('controles.index')->with('success', 'Control actualizado exitosamente.');
}
public function destroy(Control $control)
{
$this->deletePreservingHistory($control);
return redirect()->route('controles.index')->with('success', 'Control eliminado exitosamente.');
}
}
@@ -0,0 +1,206 @@
<?php
namespace App\Http\Controllers;
use App\Models\Control;
use App\Models\Riesgo;
use App\Models\TipoControl;
use App\Support\HistoricalPeriod;
use App\Support\RiskCalculator;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class ControlGestionController extends Controller
{
public function show(Control $control)
{
$control->load(['tiposControles', 'riesgos.recurso', 'riesgos.amenaza', 'riesgos.vulnerabilidad']);
return Inertia::render('Controles/Gestionar', [
'control' => $control,
'tiposControles' => TipoControl::orderBy('nombre')->get(),
'riesgos' => Riesgo::orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Control $control)
{
$editableFields = ['nombre', 'descripcion', 'estado', 'nivel_de_control', 'fecha_inicio', 'fecha_fin', 'tipo_control_id'];
$validated = $request->validate([
'field' => ['required', Rule::in($editableFields)],
'value' => ['nullable'],
]);
if ($validated['field'] === 'tipo_control_id') {
$tipoId = validator(
['value' => $validated['value']],
['value' => ['required', 'exists:tipos_controles,id']],
)->validate()['value'];
$asignacionActual = DB::table('control_tipos_control')
->where('control_id', $control->id)
->whereNull('fecha_fin')
->orderByDesc('id')
->first();
if ($asignacionActual && (int) $asignacionActual->tipo_control_id === (int) $tipoId) {
return back()->with('success', 'Dato actualizado correctamente.');
}
DB::transaction(function () use ($control, $tipoId, $asignacionActual) {
$now = now();
if ($asignacionActual) {
DB::table('control_tipos_control')
->where('control_id', $control->id)
->where('id', $asignacionActual->id)
->update([
'fecha_fin' => $now,
'updated_at' => $now,
]);
}
$control->tiposControles()->attach($tipoId, [
'fecha_inicio' => $now,
'fecha_fin' => null,
'created_at' => $now,
'updated_at' => $now,
]);
});
return back()->with('success', 'Dato actualizado correctamente.');
}
$rules = match ($validated['field']) {
'nombre' => ['required', 'string', 'max:35'],
'estado' => ['nullable', 'string', Rule::in(['Implementado', 'En revisión', 'Planificado'])],
'nivel_de_control' => ['nullable', 'string', 'in:fuerte,parcial,debil'],
'descripcion' => ['nullable', 'string', 'max:185'],
'fecha_inicio', 'fecha_fin' => ['nullable', 'date'],
default => ['nullable', 'string', 'max:255'],
};
$value = validator(
['value' => $validated['value']],
['value' => $rules],
)->validate()['value'] ?? null;
if (in_array($validated['field'], ['fecha_inicio', 'fecha_fin'], true)) {
validator([
'fecha_inicio' => $validated['field'] === 'fecha_inicio' ? $value : $control->fecha_inicio,
'fecha_fin' => $validated['field'] === 'fecha_fin' ? $value : $control->fecha_fin,
], [
'fecha_inicio' => ['nullable', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
])->validate();
}
$control->update([$validated['field'] => $value]);
if (in_array($validated['field'], ['estado', 'nivel_de_control'], true)) {
$control->riesgos()->whereNull('riesgo_control.fecha_fin')->each(function (Riesgo $riesgo) {
RiskCalculator::recalculate($riesgo);
});
}
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachRiesgo(Request $request, Control $control)
{
$validated = $request->validate([
'riesgo_id' => ['required', 'integer', 'exists:riesgos,id'],
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$this->ensurePeriodDoesNotOverlap(
$control->id,
(int) $validated['riesgo_id'],
$validated['fecha_identificacion'],
$validated['fecha_fin'],
);
$control->riesgos()->attach($validated['riesgo_id'], [
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'],
]);
return back()->with('success', 'Riesgo asociado correctamente.');
}
public function updateRiesgoPivot(Request $request, Control $control, int $pivotId)
{
$validated = $request->validate([
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$pivot = DB::table('riesgo_control')
->where('control_id', $control->id)
->where('id', $pivotId)
->firstOrFail();
$this->ensurePeriodDoesNotOverlap(
$control->id,
(int) $pivot->riesgo_id,
$validated['fecha_identificacion'],
$validated['fecha_fin'],
$pivotId,
);
DB::table('riesgo_control')
->where('control_id', $control->id)
->where('id', $pivotId)
->update([
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachRiesgo(Control $control, int $pivotId)
{
DB::table('riesgo_control')->where('control_id', $control->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de riesgo eliminada correctamente.');
}
private function ensurePeriodDoesNotOverlap(
int $controlId,
int $riesgoId,
string $start,
?string $end,
?int $excludedPivotId = null,
): void {
$periods = DB::table('riesgo_control')
->where('control_id', $controlId)
->where('riesgo_id', $riesgoId)
->when($excludedPivotId, fn ($query) => $query->where('id', '!=', $excludedPivotId))
->get();
$startDate = Carbon::parse($start);
$endDate = $end ? Carbon::parse($end) : null;
foreach ($periods as $period) {
$otherStart = Carbon::parse($period->fecha_identificacion);
$otherEnd = $period->fecha_fin ? Carbon::parse($period->fecha_fin) : null;
$startsBeforeOtherEnds = $otherEnd === null || $startDate->lte($otherEnd);
$endsAfterOtherStarts = $endDate === null || $endDate->gte($otherStart);
if ($startsBeforeOtherEnds && $endsAfterOtherStarts) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_identificacion' => 'Las fechas chocan con una asignación existente.',
]);
}
}
}
}
+91
View File
@@ -0,0 +1,91 @@
<?php
namespace App\Http\Controllers;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\QueryException;
use Illuminate\Validation\ValidationException;
abstract class Controller
{
protected function deletePreservingHistory(Model $model): void
{
try {
$model->delete();
} catch (QueryException $exception) {
if ((string) $exception->getCode() !== '23000') {
throw $exception;
}
throw ValidationException::withMessages([
'delete' => 'No se puede eliminar porque existen relaciones o historial asociado.',
]);
}
}
protected function applySearch(Builder $query, ?string $search, array $columns): Builder
{
$search = trim((string) $search);
if ($search === '') {
return $query;
}
return $query->where(function (Builder $query) use ($search, $columns) {
foreach ($columns as $index => $column) {
$method = $index === 0 ? 'where' : 'orWhere';
$query->{$method}($column, 'like', "%{$search}%");
}
});
}
protected function paginated(Builder $query, int $perPage = 10)
{
return $query->paginate($perPage)->withQueryString();
}
protected function streamCsv(string $fileName, array $columns, $items, callable $rowMapper)
{
$headers = [
'Content-type' => 'text/csv; charset=UTF-8',
'Content-Disposition' => "attachment; filename={$fileName}",
'Pragma' => 'no-cache',
'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
'Expires' => '0',
];
$callback = function () use ($items, $columns, $rowMapper) {
$file = fopen('php://output', 'w');
fwrite($file, "\xEF\xBB\xBF");
fputcsv($file, $this->sanitizeCsvRow($columns));
foreach ($items as $item) {
fputcsv($file, $this->sanitizeCsvRow($rowMapper($item)));
}
fclose($file);
};
return response()->stream($callback, 200, $headers);
}
private function sanitizeCsvRow(array $row): array
{
return array_map([$this, 'sanitizeCsvValue'], $row);
}
private function sanitizeCsvValue($value)
{
if ($value === null) {
return null;
}
$value = (string) $value;
$trimmed = ltrim($value);
return $trimmed !== '' && in_array($trimmed[0], ['=', '+', '-', '@'], true)
? "'{$value}"
: $value;
}
}
@@ -0,0 +1,68 @@
<?php
namespace App\Http\Controllers;
use App\Models\Usuario;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class DashboardAccesosController extends Controller
{
public function index()
{
$usuariosPorTipo = Usuario::select('tipo_usuario_id', DB::raw('count(*) as total'))
->groupBy('tipo_usuario_id')
->with('tipoUsuario')
->get()
->map(fn ($item) => [
'tipo' => $item->tipoUsuario?->nombre ?? 'Sin tipo',
'total' => $item->total,
]);
$usuariosPorArea = DB::table('area_usuario')
->join('areas', 'areas.id', '=', 'area_usuario.area_id')
->select('areas.nombre as area', DB::raw('count(distinct area_usuario.usuario_id) as total'))
->groupBy('areas.nombre')
->orderByDesc('total')
->limit(12)
->get();
$rolesDistribucion = DB::table('rol_usuario')
->join('roles', 'roles.id', '=', 'rol_usuario.rol_id')
->select('roles.nombre as rol', DB::raw('count(distinct rol_usuario.usuario_id) as total'))
->groupBy('roles.nombre')
->orderByDesc('total')
->get();
$permisosPorPerfil = DB::table('permiso_perfil')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->select('perfiles.nombre as perfil', DB::raw('count(*) as total'))
->groupBy('perfiles.nombre')
->orderByDesc('total')
->get();
$perfilesPorRol = DB::table('perfil_rol')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->select('roles.nombre as rol', DB::raw('count(distinct perfil_rol.perfil_id) as total'))
->groupBy('roles.nombre')
->orderByDesc('total')
->limit(12)
->get();
$usuariosActivos = Usuario::where('activo', true)->count();
$usuariosInactivos = Usuario::where('activo', false)->count();
$totalUsuarios = Usuario::count();
return Inertia::render('Dashboards/Accesos', [
'usuariosPorTipo' => $usuariosPorTipo,
'usuariosPorArea' => $usuariosPorArea,
'rolesDistribucion' => $rolesDistribucion,
'permisosPorPerfil' => $permisosPorPerfil,
'perfilesPorRol' => $perfilesPorRol,
'usuariosActivos' => $usuariosActivos,
'usuariosInactivos' => $usuariosInactivos,
'totalUsuarios' => $totalUsuarios,
]);
}
}
@@ -0,0 +1,98 @@
<?php
namespace App\Http\Controllers;
use App\Models\Recurso;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class DashboardCatalogoController extends Controller
{
public function index()
{
$totalRecursos = Recurso::count();
$totalTipos = DB::table('tipos_recursos')->count();
$totalAreas = DB::table('areas')->count();
$recursosSinAsignar = Recurso::doesntHave('usuarios')->count();
$recursosPorTipo = Recurso::select('tipo_recurso_id', DB::raw('count(*) as total'))
->groupBy('tipo_recurso_id')
->with('tipoRecurso')
->get()
->map(fn ($item) => [
'tipo' => $item->tipoRecurso?->nombre ?? 'Sin Tipo',
'total' => $item->total,
]);
$recursosPorImpacto = Recurso::select('impacto', DB::raw('count(*) as total'))
->whereNotNull('impacto')
->groupBy('impacto')
->orderByDesc('total')
->get();
$usuariosPorTipoRecurso = DB::table('recursos')
->join('recurso_usuario', 'recursos.id', '=', 'recurso_usuario.recurso_id')
->join('tipos_recursos', 'recursos.tipo_recurso_id', '=', 'tipos_recursos.id')
->select('tipos_recursos.nombre as tipo', DB::raw('count(distinct recurso_usuario.usuario_id) as total'))
->groupBy('tipos_recursos.nombre')
->orderByDesc('total')
->get();
$recursosPorArea = DB::table('recurso_usuario')
->join('usuarios', 'usuarios.id', '=', 'recurso_usuario.usuario_id')
->join('area_usuario', 'area_usuario.usuario_id', '=', 'usuarios.id')
->join('areas', 'areas.id', '=', 'area_usuario.area_id')
->select('areas.nombre as area', DB::raw('count(distinct recurso_usuario.recurso_id) as total'))
->groupBy('areas.nombre')
->orderByDesc('total')
->get();
$topRecursosAsignados = DB::table('recurso_usuario')
->join('recursos', 'recursos.id', '=', 'recurso_usuario.recurso_id')
->select('recursos.nombre as recurso', DB::raw('count(distinct recurso_usuario.usuario_id) as total'))
->groupBy('recursos.nombre')
->orderByDesc('total')
->limit(10)
->get();
$recursosConActivos = DB::table('recurso_usuario')
->where('activo', 1)
->where(function ($q) {
$q->whereNull('fecha_fin')->orWhere('fecha_fin', '>=', now());
})
->distinct('recurso_id')
->count('recurso_id');
$recursosConInactivos = DB::table('recurso_usuario')
->where(function ($q) {
$q->where('activo', 0)
->orWhere(function ($q2) {
$q2->whereNotNull('fecha_fin')->where('fecha_fin', '<', now());
});
})
->whereNotIn('recurso_id', function ($q) {
$q->select('recurso_id')->from('recurso_usuario')
->where('activo', 1)
->where(function ($q2) {
$q2->whereNull('fecha_fin')->orWhere('fecha_fin', '>=', now());
});
})
->distinct('recurso_id')
->count('recurso_id');
return Inertia::render('Dashboards/CatalogoActivos', [
'totalRecursos' => $totalRecursos,
'totalTipos' => $totalTipos,
'totalAreas' => $totalAreas,
'recursosSinAsignar' => $recursosSinAsignar,
'recursosPorTipo' => $recursosPorTipo,
'recursosPorImpacto' => $recursosPorImpacto,
'usuariosPorTipoRecurso' => $usuariosPorTipoRecurso,
'recursosPorArea' => $recursosPorArea,
'topRecursosAsignados' => $topRecursosAsignados,
'recursosConActivos' => $recursosConActivos,
'recursosConInactivos' => $recursosConInactivos,
]);
}
}
@@ -0,0 +1,111 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\Control;
use App\Models\Recurso;
use App\Models\Riesgo;
use App\Models\Usuario;
use App\Models\Vulnerabilidad;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class DashboardController extends Controller
{
public function index()
{
$totalRiesgos = Riesgo::whereNull('fecha_baja')->count();
$metrics = [
'totalRecursos' => Recurso::count(),
'totalAmenazas' => Amenaza::count(),
'totalVulnerabilidades' => Vulnerabilidad::count(),
'totalControles' => Control::count(),
'riesgoAlto' => Riesgo::whereNull('fecha_baja')->whereIn('riesgo_inherente', ['Alto', 'Crítico'])->count(),
'usuariosSensibles' => Usuario::whereHas('roles', function ($q) {
$q->where('nombre', 'like', '%CISO%')->orWhere('nombre', 'like', '%Admin%');
})->count(),
];
$riesgosConControl = Riesgo::whereNull('fecha_baja')->whereHas('controles')->count();
$metrics['coberturaControles'] = $totalRiesgos > 0
? round(($riesgosConControl / $totalRiesgos) * 100)
: 0;
$riesgosDistribucion = Riesgo::select('riesgo_inherente as nivel_riesgo', DB::raw('count(*) as total'))
->whereNull('fecha_baja')
->whereNotNull('riesgo_inherente')
->groupBy('riesgo_inherente')
->get();
$riesgosResiduales = Riesgo::select('riesgo_residual as nivel_residual', DB::raw('count(*) as total'))
->whereNull('fecha_baja')
->whereNotNull('riesgo_residual')
->groupBy('riesgo_residual')
->get();
$controlesPorEstado = Control::select('estado', DB::raw('count(*) as total'))
->whereNotNull('estado')
->groupBy('estado')
->get();
$amenazasPorNivel = Amenaza::select('nivel_de_amenaza as nivel', DB::raw('count(*) as total'))
->whereNotNull('nivel_de_amenaza')
->groupBy('nivel_de_amenaza')
->get();
$vulnerabilidadesPorSeveridad = Vulnerabilidad::select('severidad', DB::raw('count(*) as total'))
->whereNotNull('severidad')
->groupBy('severidad')
->get();
$topRecursos = Recurso::select('id', 'nombre', 'impacto', 'tipo_recurso_id')
->withCount('riesgos as total_riesgos')
->withCount('vulnerabilidades as total_vulnerabilidades')
->withCount('usuarios as total_usuarios')
->with('tipoRecurso:id,nombre')
->orderByDesc('total_riesgos')
->limit(5)
->get()
->map(function ($recurso) {
$duenio = $recurso->usuarios->first(fn ($u) => $u->pivot->duenio);
return [
'id' => $recurso->id,
'nombre' => $recurso->nombre,
'tipo' => $recurso->tipoRecurso?->nombre ?? '-',
'impacto' => $recurso->impacto ?? '-',
'total_riesgos' => $recurso->total_riesgos,
'total_vulnerabilidades' => $recurso->total_vulnerabilidades,
'total_usuarios' => $recurso->total_usuarios,
'duenio' => $duenio ? trim("{$duenio->nombre} {$duenio->apellido}") : '-',
];
});
$severidadMap = ['Bajo' => 'Baja', 'Baja' => 'Baja', 'Medio' => 'Media', 'Media' => 'Media', 'Alto' => 'Alta', 'Alta' => 'Alta', 'Crítica' => 'Crítica'];
$impactoNorm = ['Bajo' => 'Bajo', 'Baja' => 'Bajo', 'Medio' => 'Medio', 'Media' => 'Medio', 'Alto' => 'Alto', 'Alta' => 'Alto', 'Crítico' => 'Crítico'];
$matrizVI = DB::table('recursos_vulnerabilidad')
->join('vulnerabilidades', 'vulnerabilidades.id', '=', 'recursos_vulnerabilidad.vulnerabilidad_id')
->join('recursos', 'recursos.id', '=', 'recursos_vulnerabilidad.recursos_id')
->select('vulnerabilidades.severidad', 'recursos.impacto')
->whereNull('recursos_vulnerabilidad.fecha_fin')
->get()
->map(fn ($r) => ['severidad' => $severidadMap[$r->severidad] ?? 'Crítica', 'impacto' => $impactoNorm[$r->impacto] ?? 'Medio'])
->groupBy(fn ($r) => $r['severidad'].'|'.$r['impacto'])
->map(fn ($items) => ['severidad' => $items->first()['severidad'], 'impacto' => $items->first()['impacto'], 'total' => $items->count()])
->values();
return Inertia::render('Dashboard', [
'metrics' => $metrics,
'riesgosDistribucion' => $riesgosDistribucion,
'riesgosResiduales' => $riesgosResiduales,
'controlesPorEstado' => $controlesPorEstado,
'amenazasPorNivel' => $amenazasPorNivel,
'vulnerabilidadesPorSeveridad' => $vulnerabilidadesPorSeveridad,
'topRecursos' => $topRecursos,
'matrizVI' => $matrizVI,
]);
}
}
@@ -0,0 +1,110 @@
<?php
namespace App\Http\Controllers;
use App\Models\Area;
use App\Models\Control;
use App\Models\Perfil;
use App\Models\Recurso;
use App\Models\TipoControl;
use App\Models\TipoRecurso;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class DashboardCumplimientoController extends Controller
{
public function index()
{
$controlesPorEstado = Control::select('estado', DB::raw('count(*) as total'))
->whereNotNull('estado')
->groupBy('estado')
->get();
$controlesPorTipo = TipoControl::withCount('controles')
->orderByDesc('controles_count')
->get()
->map(fn ($item) => ['tipo' => $item->nombre, 'total' => $item->controles_count]);
$recursosConUsuarios = Recurso::has('usuarios')->count();
$recursosSinUsuarios = Recurso::doesntHave('usuarios')->count();
$totalRecursos = Recurso::count();
$recursosPorImpacto = Recurso::select('impacto', DB::raw('count(*) as total'))
->whereNotNull('impacto')
->groupBy('impacto')
->orderByDesc('total')
->get();
$totalPerfiles = Perfil::count();
$perfilesConRecursos = Perfil::has('recursos')->count();
$coberturaPerfiles = $totalPerfiles > 0
? round(($perfilesConRecursos / $totalPerfiles) * 100)
: 0;
$totalAreas = Area::count();
$areasConUsuarios = Area::has('usuarios')->count();
$coberturaAreas = $totalAreas > 0
? round(($areasConUsuarios / $totalAreas) * 100)
: 0;
$coberturaRecursos = $totalRecursos > 0
? round(($recursosConUsuarios / $totalRecursos) * 100)
: 0;
$recursosPorTipo = TipoRecurso::withCount('recursos')
->orderByDesc('recursos_count')
->get()
->map(fn ($tipo) => [
'tipo' => $tipo->nombre,
'total' => $tipo->recursos_count,
'recursos' => Recurso::where('tipo_recurso_id', $tipo->id)
->withCount(['perfiles' => function ($q) {
$q->where(function ($sub) {
$sub->whereNull('perfil_recurso.fecha_fin')
->orWhere('perfil_recurso.fecha_fin', '>=', now());
});
}])
->orderByDesc('perfiles_count')
->limit(10)
->get()
->map(fn ($r) => ['nombre' => $r->nombre, 'perfiles' => $r->perfiles_count]),
]);
$hoy = now()->startOfDay();
$limite30 = now()->addDays(30);
$revisionesEstado = collect([
['estado' => 'Vencidas', 'total' => DB::table('perfil_recurso')
->whereNotNull('fecha_proxima_revision')
->where('fecha_proxima_revision', '<', $hoy)
->count()],
['estado' => 'Próximas 30 días', 'total' => DB::table('perfil_recurso')
->whereNotNull('fecha_proxima_revision')
->whereBetween('fecha_proxima_revision', [$hoy, $limite30])
->count()],
['estado' => 'Al día', 'total' => DB::table('perfil_recurso')
->whereNotNull('fecha_proxima_revision')
->where('fecha_proxima_revision', '>', $limite30)
->count()],
['estado' => 'Sin revisión', 'total' => DB::table('perfil_recurso')
->whereNull('fecha_proxima_revision')
->count()],
]);
return Inertia::render('Dashboards/Cumplimiento', [
'controlesPorEstado' => $controlesPorEstado,
'controlesPorTipo' => $controlesPorTipo,
'recursosConUsuarios' => $recursosConUsuarios,
'recursosSinUsuarios' => $recursosSinUsuarios,
'recursosPorImpacto' => $recursosPorImpacto,
'coberturaPerfiles' => $coberturaPerfiles,
'coberturaAreas' => $coberturaAreas,
'coberturaRecursos' => $coberturaRecursos,
'totalPerfiles' => $totalPerfiles,
'totalRecursos' => $totalRecursos,
'totalAreas' => $totalAreas,
'recursosPorTipo' => $recursosPorTipo,
'revisionesEstado' => $revisionesEstado,
]);
}
}
@@ -0,0 +1,122 @@
<?php
namespace App\Http\Controllers;
use App\Models\Control;
use App\Models\Riesgo;
use App\Models\TipoAmenaza;
use App\Models\TipoVulnerabilidad;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class DashboardRiesgosController extends Controller
{
public function index()
{
$amenazasPorTipo = TipoAmenaza::withCount('amenazas')
->orderByDesc('amenazas_count')
->get()
->map(fn ($item) => ['tipo' => $item->nombre, 'total' => $item->amenazas_count]);
$vulnerabilidadesPorTipo = TipoVulnerabilidad::withCount('vulnerabilidades')
->orderByDesc('vulnerabilidades_count')
->get()
->map(fn ($item) => ['tipo' => $item->nombre, 'total' => $item->vulnerabilidades_count]);
$controlesPorNivel = Control::select('nivel_de_control', DB::raw('count(*) as total'))
->whereNotNull('nivel_de_control')
->groupBy('nivel_de_control')
->get();
$riesgosConControles = Riesgo::has('controles')->count();
$riesgosSinControles = Riesgo::doesntHave('controles')->count();
$riesgosPorRecurso = Riesgo::select('recursos_id', DB::raw('count(*) as total'))
->groupBy('recursos_id')
->orderByDesc('total')
->limit(8)
->get()
->map(function ($item) {
$recurso = \App\Models\Recurso::find($item->recursos_id);
return [
'recurso' => $recurso?->nombre ?? 'Desconocido',
'total' => $item->total,
];
});
$riesgosInherentes = Riesgo::select('riesgo_inherente', DB::raw('count(*) as total'))
->whereNotNull('riesgo_inherente')
->groupBy('riesgo_inherente')
->get();
$riesgosResiduales = Riesgo::select('riesgo_residual', DB::raw('count(*) as total'))
->whereNotNull('riesgo_residual')
->groupBy('riesgo_residual')
->get();
$matrizRiesgo = Riesgo::select(
'riesgo_inherente',
'riesgo_residual',
DB::raw('count(*) as total')
)
->whereNotNull('riesgo_inherente')
->whereNotNull('riesgo_residual')
->groupBy('riesgo_inherente', 'riesgo_residual')
->get();
$totalRiesgos = Riesgo::count();
$amenazaMap = ['Bajo' => 'Bajo', 'Baja' => 'Bajo', 'Medio' => 'Moderado', 'Media' => 'Moderado', 'Alto' => 'Alto', 'Alta' => 'Alto', 'Crítico' => 'Crítico'];
$severidadMap = ['Bajo' => 'Baja', 'Baja' => 'Baja', 'Medio' => 'Media', 'Media' => 'Media', 'Alto' => 'Alta', 'Alta' => 'Alta', 'Crítica' => 'Crítica'];
$impactoNorm = ['Bajo' => 'Bajo', 'Baja' => 'Bajo', 'Medio' => 'Medio', 'Media' => 'Medio', 'Alto' => 'Alto', 'Alta' => 'Alto', 'Crítico' => 'Crítico'];
$raw = Riesgo::query()
->join('amenazas', 'amenazas.id', '=', 'riesgos.amenazas_id')
->join('vulnerabilidades', 'vulnerabilidades.id', '=', 'riesgos.vulnerabilidades_id')
->select('amenazas.nivel_de_amenaza', 'vulnerabilidades.severidad')
->whereNull('riesgos.fecha_baja')
->get();
$grouped = $raw->groupBy(function ($r) use ($amenazaMap, $severidadMap) {
$a = $amenazaMap[$r->nivel_de_amenaza] ?? 'Crítico';
$v = $severidadMap[$r->severidad] ?? 'Crítica';
return $a.'|'.$v;
});
$matrizProbabilidad = $grouped->map(function ($items) use ($amenazaMap, $severidadMap) {
$first = $items->first();
$a = $amenazaMap[$first->nivel_de_amenaza] ?? 'Crítico';
$v = $severidadMap[$first->severidad] ?? 'Crítica';
return ['nivel_de_amenaza' => $a, 'severidad' => $v, 'total' => $items->count()];
})->values();
$rawPI = Riesgo::query()
->join('recursos', 'recursos.id', '=', 'riesgos.recursos_id')
->select('riesgos.probabilidad_inherente as p', 'recursos.impacto')
->whereNull('riesgos.fecha_baja')
->whereNotNull('riesgos.probabilidad_inherente')
->get()
->map(fn ($r) => ['probabilidad' => (int) $r->p, 'impacto' => $impactoNorm[$r->impacto] ?? 'Medio'])
->groupBy(fn ($r) => $r['probabilidad'].'|'.$r['impacto'])
->map(fn ($items) => ['probabilidad' => $items->first()['probabilidad'], 'impacto' => $items->first()['impacto'], 'total' => $items->count()])
->values();
return Inertia::render('Dashboards/Riesgos', [
'amenazasPorTipo' => $amenazasPorTipo,
'vulnerabilidadesPorTipo' => $vulnerabilidadesPorTipo,
'controlesPorNivel' => $controlesPorNivel,
'riesgosConControles' => $riesgosConControles,
'riesgosSinControles' => $riesgosSinControles,
'riesgosPorRecurso' => $riesgosPorRecurso,
'riesgosInherentes' => $riesgosInherentes,
'riesgosResiduales' => $riesgosResiduales,
'matrizRiesgo' => $matrizRiesgo,
'matrizProbabilidad' => $matrizProbabilidad,
'matrizPI' => $rawPI,
'totalRiesgos' => $totalRiesgos,
]);
}
}
@@ -0,0 +1,250 @@
<?php
namespace App\Http\Controllers;
use App\Models\Control;
use App\Models\Perfil;
use App\Models\Permiso;
use App\Models\Rol;
use App\Models\TipoAmenaza;
use App\Models\TipoControl;
use App\Models\TipoRecurso;
use App\Models\TipoUsuario;
use App\Models\TipoVulnerabilidad;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class GenericGestionController extends Controller
{
public function control(Control $control)
{
$control->load(['tiposControles', 'riesgos']);
return $this->render('Control', 'controles.index', 'controles.campo.update', $control, [
['name' => 'nombre', 'label' => 'Nombre'],
['name' => 'nivel_de_control', 'label' => 'Nivel de control', 'type' => 'select', 'options' => $this->options(['fuerte', 'parcial', 'debil'])],
['name' => 'descripcion', 'label' => 'Descripción', 'type' => 'textarea', 'md' => 8],
['name' => 'estado', 'label' => 'Estado'],
['name' => 'fecha_inicio', 'label' => 'Inicio', 'type' => 'date'],
['name' => 'fecha_fin', 'label' => 'Fin', 'type' => 'date'],
], [
$this->relation('Tipos de control', $control->tiposControles, 'tipos-controles.gestionar'),
$this->riesgosRelation($control->riesgos),
]);
}
public function updateControl(Request $request, Control $control)
{
return $this->updateField($request, $control, ['nombre', 'descripcion', 'estado', 'nivel_de_control', 'fecha_inicio', 'fecha_fin']);
}
public function rol(Rol $rol)
{
return $this->render('Rol', 'roles.index', 'roles.campo.update', $rol->load(['usuarios', 'perfiles']), [
['name' => 'nombre', 'label' => 'Nombre'],
['name' => 'descripcion', 'label' => 'Descripción', 'type' => 'textarea', 'md' => 8],
['name' => 'fecha_inicio', 'label' => 'Inicio', 'type' => 'date'],
['name' => 'fecha_fin', 'label' => 'Fin', 'type' => 'date'],
], [
$this->relation('Usuarios', $rol->usuarios, 'usuarios.gestionar', fn ($usuario) => trim($usuario->nombre.' '.$usuario->apellido)),
$this->relation('Perfiles', $rol->perfiles, 'perfiles.gestionar'),
]);
}
public function updateRol(Request $request, Rol $rol)
{
return $this->updateField($request, $rol, ['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin']);
}
public function perfil(Perfil $perfil)
{
return $this->render('Perfil', 'perfiles.index', 'perfiles.campo.update', $perfil->load(['roles', 'permisos']), [
['name' => 'nombre', 'label' => 'Nombre'],
['name' => 'descripcion', 'label' => 'Descripción', 'type' => 'textarea', 'md' => 8],
['name' => 'fecha_inicio', 'label' => 'Inicio', 'type' => 'date'],
['name' => 'fecha_fin', 'label' => 'Fin', 'type' => 'date'],
], [
$this->relation('Roles', $perfil->roles, 'roles.gestionar'),
$this->relation('Permisos', $perfil->permisos, 'permisos.gestionar'),
]);
}
public function updatePerfil(Request $request, Perfil $perfil)
{
return $this->updateField($request, $perfil, ['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin']);
}
public function permiso(Permiso $permiso)
{
return $this->render('Permiso', 'permisos.index', 'permisos.campo.update', $permiso->load('perfiles'), [
['name' => 'nombre', 'label' => 'Nombre'],
['name' => 'accion', 'label' => 'Acción'],
['name' => 'estado', 'label' => 'Estado'],
['name' => 'justificacion', 'label' => 'Justificación', 'type' => 'textarea', 'md' => 12],
], [
$this->relation('Perfiles', $permiso->perfiles, 'perfiles.gestionar'),
]);
}
public function updatePermiso(Request $request, Permiso $permiso)
{
return $this->updateField($request, $permiso, ['nombre', 'accion', 'estado', 'justificacion']);
}
public function tipoUsuario(TipoUsuario $tipoUsuario)
{
return $this->renderTipo('Tipo de usuario', 'tipos-usuarios.index', 'tipos-usuarios.campo.update', $tipoUsuario->load('usuarios'), 'Usuarios', $tipoUsuario->usuarios, 'usuarios.gestionar', fn ($usuario) => trim($usuario->nombre.' '.$usuario->apellido));
}
public function updateTipoUsuario(Request $request, TipoUsuario $tipoUsuario)
{
return $this->updateField($request, $tipoUsuario, ['nombre', 'descripcion']);
}
public function tipoRecurso(TipoRecurso $tipoRecurso)
{
return $this->renderTipo('Tipo de recurso', 'tipos-recursos.index', 'tipos-recursos.campo.update', $tipoRecurso->load('recursos'), 'Recursos', $tipoRecurso->recursos, 'recursos.gestionar');
}
public function updateTipoRecurso(Request $request, TipoRecurso $tipoRecurso)
{
return $this->updateField($request, $tipoRecurso, ['nombre', 'descripcion']);
}
public function tipoAmenaza(TipoAmenaza $tipoAmenaza)
{
return $this->renderTipo('Tipo de amenaza', 'tipos-amenazas.index', 'tipos-amenazas.campo.update', $tipoAmenaza->load('amenazas'), 'Amenazas', $tipoAmenaza->amenazas, 'amenazas.gestionar');
}
public function updateTipoAmenaza(Request $request, TipoAmenaza $tipoAmenaza)
{
return $this->updateField($request, $tipoAmenaza, ['nombre', 'descripcion']);
}
public function tipoControl(TipoControl $tipoControl)
{
return $this->renderTipo('Tipo de control', 'tipos-controles.index', 'tipos-controles.campo.update', $tipoControl->load('controles'), 'Controles', $tipoControl->controles, 'controles.gestionar');
}
public function updateTipoControl(Request $request, TipoControl $tipoControl)
{
return $this->updateField($request, $tipoControl, ['nombre', 'descripcion']);
}
public function tipoVulnerabilidad(TipoVulnerabilidad $tipoVulnerabilidad)
{
return $this->renderTipo('Tipo de vulnerabilidad', 'tipos-vulnerabilidades.index', 'tipos-vulnerabilidades.campo.update', $tipoVulnerabilidad->load('vulnerabilidades'), 'Vulnerabilidades', $tipoVulnerabilidad->vulnerabilidades, 'vulnerabilidades.gestionar');
}
public function updateTipoVulnerabilidad(Request $request, TipoVulnerabilidad $tipoVulnerabilidad)
{
return $this->updateField($request, $tipoVulnerabilidad, ['nombre', 'descripcion']);
}
private function renderTipo(string $entityName, string $indexRoute, string $updateRoute, Model $entity, string $relationLabel, $rows, string $linkRoute, ?callable $label = null)
{
return $this->render($entityName, $indexRoute, $updateRoute, $entity, [
['name' => 'nombre', 'label' => 'Nombre'],
['name' => 'descripcion', 'label' => 'Descripción', 'type' => 'textarea', 'md' => 12],
], [
$this->relation($relationLabel, $rows, $linkRoute, $label),
]);
}
private function render(string $entityName, string $indexRoute, string $updateRoute, Model $entity, array $fields, array $relations = [])
{
return Inertia::render('Generic/Gestionar', [
'title' => $entity->nombre ?? ('#'.$entity->id),
'entityName' => $entityName,
'entity' => $entity,
'fields' => $fields,
'relations' => $relations,
'indexRoute' => $indexRoute,
'updateRoute' => $updateRoute,
]);
}
private function relation(string $label, $rows, string $linkRoute, ?callable $nameResolver = null): array
{
return [
'label' => $label,
'rows' => collect($rows)->map(fn ($row) => [
'id' => $row->id,
'nombre' => $nameResolver ? $nameResolver($row) : ($row->nombre ?? '#'.$row->id),
'descripcion' => $row->descripcion ?? null,
])->values(),
'columns' => [
['key' => 'nombre', 'label' => 'Nombre', 'linkRoute' => $linkRoute],
['key' => 'descripcion', 'label' => 'Descripción'],
],
];
}
private function riesgosRelation($riesgos): array
{
$formatDate = fn ($value) => $value ? date('d/m/Y', strtotime($value)) : '-';
return [
'label' => 'Riesgos asociados',
'rows' => collect($riesgos)->map(fn ($riesgo) => [
'id' => $riesgo->id,
'nombre' => $riesgo->nombre ?? '#'.$riesgo->id,
'riesgo_inherente' => $riesgo->riesgo_inherente ?? '-',
'riesgo_residual' => $riesgo->riesgo_residual ?? '-',
'total_efect' => $riesgo->total_efect ?? '-',
'fecha_identificacion' => $formatDate($riesgo->pivot->fecha_identificacion),
'fecha_fin' => $formatDate($riesgo->pivot->fecha_fin),
])->values(),
'columns' => [
['key' => 'nombre', 'label' => 'Riesgo', 'linkRoute' => 'riesgos.gestionar'],
['key' => 'riesgo_inherente', 'label' => 'Inherente'],
['key' => 'riesgo_residual', 'label' => 'Residual'],
['key' => 'total_efect', 'label' => 'Efectividad'],
['key' => 'fecha_identificacion', 'label' => 'Identificación'],
['key' => 'fecha_fin', 'label' => 'Fin'],
],
];
}
private function updateField(Request $request, Model $model, array $allowedFields)
{
$validated = $request->validate([
'field' => ['required', Rule::in($allowedFields)],
'value' => ['nullable'],
]);
$rules = match ($validated['field']) {
'nombre' => ['required', 'string', 'max:35'],
'accion' => ['required', 'string', 'max:185'],
'nivel_de_control' => ['nullable', 'string', 'in:fuerte,parcial,debil'],
'descripcion', 'justificacion' => ['nullable', 'string', 'max:185'],
'fecha_inicio', 'fecha_fin' => ['nullable', 'date'],
default => ['nullable', 'string', 'max:255'],
};
$value = validator(
['value' => $validated['value']],
['value' => $rules],
)->validate()['value'] ?? null;
if (in_array($validated['field'], ['fecha_inicio', 'fecha_fin'], true)) {
validator([
'fecha_inicio' => $validated['field'] === 'fecha_inicio' ? $value : $model->fecha_inicio,
'fecha_fin' => $validated['field'] === 'fecha_fin' ? $value : $model->fecha_fin,
], [
'fecha_inicio' => ['nullable', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
])->validate();
}
$model->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
private function options(array $values): array
{
return collect($values)->map(fn ($value) => ['value' => $value, 'label' => $value])->all();
}
}
@@ -0,0 +1,97 @@
<?php
namespace App\Http\Controllers;
use App\Models\Notificacion;
use App\Services\NotificacionService;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Inertia\Inertia;
class NotificacionController extends Controller
{
public function __construct(
private NotificacionService $service
) {}
private function applyNotificacionFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['titulo', 'mensaje']);
if ($request->filled('texto')) {
$query->where('mensaje', 'like', '%'.trim((string) $request->input('texto')).'%');
}
if ($request->filled('titulo')) {
$query->where('titulo', 'like', '%'.trim((string) $request->input('titulo')).'%');
}
if ($request->input('leido') !== null && $request->input('leido') !== '') {
$query->where('leido', $request->boolean('leido'));
}
if ($request->filled('fecha_desde')) {
$query->whereDate('created_at', '>=', $request->input('fecha_desde'));
}
if ($request->filled('fecha_hasta')) {
$query->whereDate('created_at', '<=', $request->input('fecha_hasta'));
}
return $query;
}
public function index(Request $request)
{
$this->service->generarNotificacionesPendientes();
$filterKeys = ['search', 'texto', 'titulo', 'leido', 'fecha_desde', 'fecha_hasta'];
$query = Notificacion::query()->where('user_id', Auth::id());
$this->applyNotificacionFilters($query, $request);
return Inertia::render('Notificaciones/Index', [
'items' => $query->orderByDesc('created_at')->orderByDesc('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'leidos' => [
['value' => '1', 'label' => 'Leída'],
['value' => '0', 'label' => 'No leída'],
],
],
]);
}
public function count(): JsonResponse
{
$this->service->generarNotificacionesPendientes();
$noLeidas = Notificacion::where('user_id', Auth::id())
->where('leido', false)
->count();
$recientes = Notificacion::where('user_id', Auth::id())
->where('leido', false)
->latest()
->take(5)
->get(['id', 'titulo', 'mensaje', 'created_at']);
return response()->json([
'count' => $noLeidas,
'recientes' => $recientes,
]);
}
public function leer(Request $request, string $id): \Illuminate\Http\RedirectResponse
{
Notificacion::where('id', $id)->where('user_id', Auth::id())->update(['leido' => true]);
return back();
}
public function leerTodas(): \Illuminate\Http\RedirectResponse
{
Notificacion::where('user_id', Auth::id())
->where('leido', false)
->update(['leido' => true]);
return back();
}
}
@@ -0,0 +1,13 @@
<?php
namespace App\Http\Controllers;
use Inertia\Inertia;
class PendienteController extends Controller
{
public function index()
{
return Inertia::render('Pendiente/Welcome');
}
}
+114
View File
@@ -0,0 +1,114 @@
<?php
namespace App\Http\Controllers;
use App\Models\Perfil;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class PerfilController extends Controller
{
private function applyPerfilFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
if ($request->input('vigencia') === 'vigente') {
$query->where(function (Builder $query): void {
$query->whereNull('fecha_inicio')->orWhereDate('fecha_inicio', '<=', today());
});
$query->where(function (Builder $query): void {
$query->whereNull('fecha_fin')->orWhereDate('fecha_fin', '>=', today());
});
} elseif ($request->input('vigencia') === 'vencido') {
$query->whereDate('fecha_fin', '<', today());
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'vigencia'];
$query = Perfil::query();
$this->applyPerfilFilters($query, $request);
return Inertia::render('Perfiles/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'vigencias' => [
['value' => 'vigente', 'label' => 'Vigente'],
['value' => 'vencido', 'label' => 'Vencido'],
],
],
]);
}
public function export(Request $request)
{
$query = Perfil::query();
$this->applyPerfilFilters($query, $request);
$items = $query->get();
$fileName = 'perfiles_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Nombre', 'Descripción', 'Fecha Inicio', 'Fecha Fin'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id, $item->nombre, $item->descripcion, $item->fecha_inicio, $item->fecha_fin,
]);
}
public function create()
{
return Inertia::render('Perfiles/Create');
}
public function store(Request $request)
{
$request->validate([
'nombre' => 'required|string|max:35',
'fecha_inicio' => 'required|date',
'fecha_fin' => 'nullable|date|after_or_equal:fecha_inicio',
'descripcion' => 'nullable|string|max:185',
]);
Perfil::create($request->only(['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin']));
return redirect()->route('perfiles.index')->with('success', 'Perfil creado exitosamente.');
}
public function edit(Perfil $perfil)
{
return Inertia::render('Perfiles/Edit', [
'item' => $perfil,
]);
}
public function update(Request $request, Perfil $perfil)
{
$request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
$perfil->update($request->only(['nombre', 'descripcion']));
return redirect()->route('perfiles.index')->with('success', 'Perfil actualizado exitosamente.');
}
public function destroy(Perfil $perfil)
{
$this->deletePreservingHistory($perfil);
return redirect()->route('perfiles.index')->with('success', 'Perfil eliminado exitosamente.');
}
}
@@ -0,0 +1,342 @@
<?php
namespace App\Http\Controllers;
use App\Models\Perfil;
use App\Models\Permiso;
use App\Models\Recurso;
use App\Models\Rol;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class PerfilGestionController extends Controller
{
public function show(Perfil $perfil)
{
return Inertia::render('Perfiles/Gestionar', [
'perfil' => $perfil->load(['roles', 'permisos', 'recursos.tipoRecurso']),
'roles' => Rol::orderBy('nombre')->get(),
'permisos' => Permiso::orderBy('nombre')->get(),
'recursos' => Recurso::with('tipoRecurso')->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Perfil $perfil)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin'])],
'value' => ['nullable'],
]);
$rules = match ($validated['field']) {
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'fecha_inicio', 'fecha_fin' => ['nullable', 'date'],
};
$value = validator(
['value' => $validated['value']],
['value' => $rules],
)->validate()['value'] ?? null;
if (in_array($validated['field'], ['fecha_inicio', 'fecha_fin'], true)) {
validator([
'fecha_inicio' => $validated['field'] === 'fecha_inicio' ? $value : $perfil->fecha_inicio,
'fecha_fin' => $validated['field'] === 'fecha_fin' ? $value : $perfil->fecha_fin,
], [
'fecha_inicio' => ['nullable', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
])->validate();
}
$perfil->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachRol(Request $request, Perfil $perfil)
{
$validated = $request->validate([
'rol_id' => ['required', 'exists:roles,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_rol')->where('perfil_id', $perfil->id)->where('rol_id', $validated['rol_id'])->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
$perfil->roles()->attach($validated['rol_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Rol asociado correctamente.');
}
public function detachRol(Perfil $perfil, $pivotId)
{
DB::table('perfil_rol')->where('perfil_id', $perfil->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de rol eliminada correctamente.');
}
public function updateRolPivot(Request $request, Perfil $perfil, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('perfil_rol')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_rol')->where('perfil_id', $perfil->id)->where('rol_id', $registroActual->rol_id)->where('id', '!=', $pivotId)->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
DB::table('perfil_rol')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function attachPermiso(Request $request, Perfil $perfil)
{
$validated = $request->validate([
'permiso_id' => ['required', 'exists:permisos,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('permiso_perfil')->where('perfil_id', $perfil->id)->where('permiso_id', $validated['permiso_id'])->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
$perfil->permisos()->attach($validated['permiso_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Permiso asociado correctamente.');
}
public function detachPermiso(Perfil $perfil, $pivotId)
{
DB::table('permiso_perfil')->where('perfil_id', $perfil->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de permiso eliminada correctamente.');
}
public function updatePermisoPivot(Request $request, Perfil $perfil, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$registroActual = DB::table('permiso_perfil')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('permiso_perfil')->where('perfil_id', $perfil->id)->where('permiso_id', $registroActual->permiso_id)->where('id', '!=', $pivotId)->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
DB::table('permiso_perfil')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function attachRecurso(Request $request, Perfil $perfil)
{
$validated = $this->validateRecursoPivot($request, true);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($perfil, $validated): void {
Perfil::query()->whereKey($perfil->id)->lockForUpdate()->firstOrFail();
$this->ensureNoRecursoOverlap(
$perfil,
(int) $validated['recurso_id'],
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
);
$perfil->recursos()->attach($validated['recurso_id'], [
'evidencia' => $validated['evidencia'] ?? null,
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'fecha_revision' => $validated['fecha_revision'] ?? null,
'fecha_proxima_revision' => $validated['fecha_proxima_revision'] ?? null,
]);
});
return back()->with('success', 'Recurso asociado correctamente.');
}
public function updateRecursoPivot(Request $request, Perfil $perfil, int $pivotId)
{
$validated = $this->validateRecursoPivot($request);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($perfil, $pivotId, $validated): void {
Perfil::query()->whereKey($perfil->id)->lockForUpdate()->firstOrFail();
$pivot = DB::table('perfil_recurso')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->firstOrFail();
$this->ensureNoRecursoOverlap(
$perfil,
(int) $pivot->recurso_id,
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
$pivotId,
);
DB::table('perfil_recurso')
->where('perfil_id', $perfil->id)
->where('id', $pivotId)
->update([...$validated, 'updated_at' => now()]);
});
return back()->with('success', 'Asignación de recurso actualizada correctamente.');
}
public function detachRecurso(Perfil $perfil, int $pivotId)
{
DB::table('perfil_recurso')->where('perfil_id', $perfil->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de recurso eliminada correctamente.');
}
private function validateRecursoPivot(Request $request, bool $requiresResource = false): array
{
$rules = [
'evidencia' => ['nullable', 'string'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'fecha_revision' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'fecha_proxima_revision' => ['nullable', 'date', 'after_or_equal:fecha_revision'],
];
if ($requiresResource) {
$rules['recurso_id'] = ['required', 'integer', 'exists:recursos,id'];
}
return $request->validate($rules);
}
private function ensureNoRecursoOverlap(
Perfil $perfil,
int $recursoId,
string $fechaInicio,
?string $fechaFin,
?int $exceptPivotId = null,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('perfil_recurso')
->where('perfil_id', $perfil->id)
->where('recurso_id', $recursoId);
if ($exceptPivotId !== null) {
$query->where('id', '!=', $exceptPivotId);
}
foreach ($query->get() as $otro) {
if (! $otro->fecha_inicio) {
continue;
}
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null || $inicio->lte($otroFin)) && ($fin === null || $fin->gte($otroInicio))) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'El período se superpone con otra asignación del recurso al perfil.',
]);
}
}
}
}
+110
View File
@@ -0,0 +1,110 @@
<?php
namespace App\Http\Controllers;
use App\Models\Permiso;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class PermisoController extends Controller
{
private function applyPermisoFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'accion', 'estado', 'justificacion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('accion')) {
$query->where('accion', 'like', '%'.trim((string) $request->input('accion')).'%');
}
if ($request->filled('estado')) {
$query->where('estado', $request->input('estado'));
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'accion', 'estado'];
$query = Permiso::query();
$this->applyPermisoFilters($query, $request);
return Inertia::render('Permisos/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'estados' => Permiso::query()
->select('estado as value', 'estado as label')
->whereNotNull('estado')
->where('estado', '<>', '')
->distinct()
->orderBy('estado')
->get(),
],
]);
}
public function export(Request $request)
{
$query = Permiso::query();
$this->applyPermisoFilters($query, $request);
$items = $query->get();
$fileName = 'permisos_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Nombre', 'Acción', 'Estado', 'Justificación'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id, $item->nombre, $item->accion, $item->estado, $item->justificacion,
]);
}
public function create()
{
return Inertia::render('Permisos/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'estado' => 'nullable|string|in:1,0',
'accion' => 'required|string|max:185',
'justificacion' => 'nullable|string|max:185',
]);
Permiso::create($validated);
return redirect()->route('permisos.index')->with('success', 'Permiso creado exitosamente.');
}
public function edit(Permiso $permiso)
{
return redirect()->route('permisos.gestionar', $permiso->id);
}
public function update(Request $request, Permiso $permiso)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'estado' => 'nullable|string|in:1,0',
'accion' => 'required|string|max:185',
'justificacion' => 'nullable|string|max:185',
]);
$permiso->update($validated);
return redirect()->route('permisos.index')->with('success', 'Permiso actualizado exitosamente.');
}
public function destroy(Permiso $permiso)
{
$this->deletePreservingHistory($permiso);
return redirect()->route('permisos.index')->with('success', 'Permiso eliminado exitosamente.');
}
}
@@ -0,0 +1,131 @@
<?php
namespace App\Http\Controllers;
use App\Models\Perfil;
use App\Models\Permiso;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class PermisoGestionController extends Controller
{
public function show(Permiso $permiso)
{
return Inertia::render('Permisos/Gestionar', [
'permiso' => $permiso->load('perfiles'),
'perfiles' => Perfil::orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Permiso $permiso)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'accion', 'estado', 'justificacion'])],
'value' => ['nullable'],
]);
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'accion' => ['required', 'string', 'max:185'],
'estado' => ['nullable', 'string', 'in:1,0'],
'justificacion' => ['nullable', 'string', 'max:185'],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
$permiso->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachPerfil(Request $request, Permiso $permiso)
{
$validated = $request->validate([
'perfil_id' => ['required', 'exists:perfiles,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('permiso_perfil')->where('permiso_id', $permiso->id)->where('perfil_id', $validated['perfil_id'])->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
$permiso->perfiles()->attach($validated['perfil_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Perfil asociado correctamente.');
}
public function detachPerfil(Permiso $permiso, $pivotId)
{
DB::table('permiso_perfil')->where('permiso_id', $permiso->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de perfil eliminada correctamente.');
}
public function updatePerfilPivot(Request $request, Permiso $permiso, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$registroActual = DB::table('permiso_perfil')
->where('permiso_id', $permiso->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('permiso_perfil')->where('permiso_id', $permiso->id)->where('perfil_id', $registroActual->perfil_id)->where('id', '!=', $pivotId)->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
DB::table('permiso_perfil')
->where('permiso_id', $permiso->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
}
@@ -0,0 +1,67 @@
<?php
namespace App\Http\Controllers;
use App\Http\Requests\ProfileUpdateRequest;
use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Redirect;
use Inertia\Inertia;
use Inertia\Response;
class ProfileController extends Controller
{
/**
* Display the user's profile form.
*/
public function edit(Request $request): Response
{
return Inertia::render('Profile/Edit', [
'mustVerifyEmail' => $request->user() instanceof MustVerifyEmail,
'status' => session('status'),
]);
}
/**
* Update the user's profile information.
*/
public function update(ProfileUpdateRequest $request): RedirectResponse
{
$request->user()->fill($request->validated());
if ($request->user()->isDirty('email')) {
$request->user()->email_verified_at = null;
}
$request->user()->save();
return Redirect::route('profile.edit');
}
/**
* Delete the user's account.
*/
public function destroy(Request $request): RedirectResponse
{
$request->validate([
'password' => ['required', 'current_password'],
]);
$user = $request->user();
if ($user->hasRole('administrador')) {
return back()->withErrors(['password' => 'Los administradores no pueden eliminar su propia cuenta. Contactá a otro administrador.']);
}
Auth::logout();
$user->delete();
$request->session()->invalidate();
$request->session()->regenerateToken();
return Redirect::to('/');
}
}
+158
View File
@@ -0,0 +1,158 @@
<?php
namespace App\Http\Controllers;
use App\Models\Recurso;
use App\Models\TipoRecurso;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class RecursoController extends Controller
{
private function applyRecursoFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion', 'impacto']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
if ($request->filled('tipo_recurso_id')) {
$tipoId = $request->input('tipo_recurso_id');
$query->whereHas('tipoRecurso', function (Builder $query) use ($tipoId): void {
$query->where('tipos_recursos.id', $tipoId);
});
}
if ($request->filled('impacto')) {
$query->where('impacto', $request->input('impacto'));
}
if ($request->input('vigencia') === 'vigente') {
$query->where(function (Builder $query): void {
$query->whereNull('fecha_alta')->orWhereDate('fecha_alta', '<=', today());
});
$query->where(function (Builder $query): void {
$query->whereNull('fecha_baja')->orWhereDate('fecha_baja', '>', today());
});
} elseif ($request->input('vigencia') === 'baja') {
$query->whereDate('fecha_baja', '<=', today());
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'tipo_recurso_id', 'impacto', 'vigencia'];
$query = Recurso::with(['tipoRecurso', 'responsables']);
$this->applyRecursoFilters($query, $request);
return Inertia::render('Recursos/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'tiposRecursos' => TipoRecurso::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
'impactos' => Recurso::query()
->select('impacto as value', 'impacto as label')
->whereNotNull('impacto')
->where('impacto', '<>', '')
->distinct()
->orderBy('impacto')
->get(),
'vigencias' => [
['value' => 'vigente', 'label' => 'Vigente'],
['value' => 'baja', 'label' => 'Baja'],
],
],
]);
}
public function export(Request $request)
{
$query = Recurso::query();
$this->applyRecursoFilters($query, $request);
$items = $query->get();
$fileName = 'recursos_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Nombre', 'Descripción', 'Impacto', 'Fecha Alta', 'Fecha Baja'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id,
$item->nombre,
$item->descripcion,
$item->impacto,
$item->fecha_alta,
$item->fecha_baja,
]);
}
public function create()
{
return Inertia::render('Recursos/Create', [
'tipos_recursos' => TipoRecurso::query()->orderBy('nombre')->get(),
]);
}
public function store(Request $request)
{
$request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'tipo_recurso_id' => 'required|exists:tipos_recursos,id',
'impacto' => 'nullable|string|in:Bajo,Medio,Alto,Crítico',
'fecha_alta' => 'nullable|date',
'fecha_baja' => 'nullable|date|after_or_equal:fecha_alta',
]);
Recurso::create($request->only(['nombre', 'descripcion', 'tipo_recurso_id', 'impacto', 'fecha_alta', 'fecha_baja']));
return redirect()->route('recursos.index')->with('success', 'Recurso creado exitosamente.');
}
public function edit(Recurso $recurso)
{
return Inertia::render('Recursos/Edit', [
'item' => $recurso,
]);
}
public function update(Request $request, Recurso $recurso)
{
$request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'tipo_recurso_id' => 'required|exists:tipos_recursos,id',
'impacto' => 'nullable|string|in:Bajo,Medio,Alto,Crítico',
'fecha_alta' => 'nullable|date',
'fecha_baja' => 'nullable|date|after_or_equal:fecha_alta',
]);
$recurso->update($request->only(['nombre', 'descripcion', 'tipo_recurso_id', 'impacto', 'fecha_alta', 'fecha_baja']));
return redirect()->route('recursos.index')->with('success', 'Recurso actualizado exitosamente.');
}
public function destroy(Recurso $recurso)
{
$riesgosCount = $recurso->riesgos()->count();
if ($riesgosCount > 0) {
return back()->withErrors([
'recurso' => "Este recurso tiene {$riesgosCount} riesgo(s) asociado(s). Eliminá los riesgos primero.",
]);
}
DB::table('recurso_usuario')->where('recurso_id', $recurso->id)->delete();
DB::table('recursos_vulnerabilidad')->where('recursos_id', $recurso->id)->delete();
DB::table('perfil_recurso')->where('recurso_id', $recurso->id)->delete();
DB::table('area_recurso')->where('recurso_id', $recurso->id)->delete();
$this->deletePreservingHistory($recurso);
return redirect()->route('recursos.index')->with('success', 'Recurso eliminado exitosamente.');
}
}
@@ -0,0 +1,493 @@
<?php
namespace App\Http\Controllers;
use App\Models\Area;
use App\Models\Perfil;
use App\Models\Recurso;
use App\Models\TipoRecurso;
use App\Models\Usuario;
use App\Models\Vulnerabilidad;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
class RecursoGestionController extends Controller
{
public function show(Recurso $recurso)
{
return Inertia::render('Recursos/Gestionar', [
'recurso' => $recurso->load([
'tipoRecurso',
'usuarios',
'areas',
'perfiles',
'vulnerabilidades',
'riesgos.amenaza',
'riesgos.vulnerabilidad',
]),
'usuarios' => Usuario::query()->where('activo', true)->orderBy('nombre')->get(),
'tiposRecursos' => TipoRecurso::query()->orderBy('nombre')->get(),
'areas' => Area::query()->orderBy('nombre')->get(),
'perfiles' => Perfil::query()->orderBy('nombre')->get(),
'vulnerabilidades' => Vulnerabilidad::query()->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Recurso $recurso)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'descripcion', 'tipo_recurso_id', 'impacto', 'fecha_alta', 'fecha_baja'])],
'value' => ['nullable'],
]);
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'tipo_recurso_id' => ['required', 'exists:tipos_recursos,id'],
'impacto' => ['nullable', 'string', 'in:Bajo,Medio,Alto,Crítico'],
'fecha_alta' => ['nullable', 'date'],
'fecha_baja' => ['nullable', 'date'],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
$fechas = [
'fecha_alta' => $validated['field'] === 'fecha_alta' ? $value : $recurso->fecha_alta,
'fecha_baja' => $validated['field'] === 'fecha_baja' ? $value : $recurso->fecha_baja,
];
validator($fechas, [
'fecha_alta' => ['nullable', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
])->validate();
$recurso->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachUsuario(Request $request, Recurso $recurso)
{
$validated = $request->validate([
'usuario_id' => ['required', 'exists:usuarios,id'],
'duenio' => ['nullable', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
DB::transaction(function () use ($recurso, $validated, $request): void {
Recurso::query()->whereKey($recurso->id)->lockForUpdate()->firstOrFail();
$this->ensureNoOverlap(
$recurso,
(int) $validated['usuario_id'],
$validated['fecha_inicio'],
$validated['fecha_fin'] ?? null,
);
$recurso->usuarios()->attach($validated['usuario_id'], [
'activo' => true,
'duenio' => $request->boolean('duenio'),
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
});
return back()->with('success', 'Usuario asociado correctamente.');
}
public function detachUsuario(Recurso $recurso, $pivotId)
{
DB::table('recurso_usuario')->where('recurso_id', $recurso->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación eliminada correctamente.');
}
public function updateUsuarioPivot(Request $request, Recurso $recurso, $pivotId)
{
$validated = $request->validate([
'duenio' => ['required', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('recurso_usuario')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recurso_usuario')
->where('recurso_id', $recurso->id)
->where('usuario_id', $registroActual->usuario_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeQueTermineElOtro = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespuesDeQueEmpieceElOtro = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntesDeQueTermineElOtro && $terminaDespuesDeQueEmpieceElOtro) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con otro registro existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
DB::table('recurso_usuario')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->update([
'duenio' => $validated['duenio'],
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
private function ensureNoOverlap(
Recurso $recurso,
int $usuarioId,
string $fechaInicio,
?string $fechaFin,
?int $exceptPivotId = null,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('recurso_usuario')
->where('recurso_id', $recurso->id)
->where('usuario_id', $usuarioId);
if ($exceptPivotId !== null) {
$query->where('id', '!=', $exceptPivotId);
}
foreach ($query->get() as $otro) {
if (! $otro->fecha_inicio) {
continue;
}
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null || $inicio->lte($otroFin)) && ($fin === null || $fin->gte($otroInicio))) {
throw ValidationException::withMessages([
'fecha_inicio' => 'El período se superpone con otra asignación del usuario al recurso.',
]);
}
}
}
public function attachArea(Request $request, Recurso $recurso)
{
$validated = $request->validate([
'area_id' => ['required', 'exists:areas,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('area_recurso')
->where('recurso_id', $recurso->id)
->where('area_id', $validated['area_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para esta área.',
]);
}
}
$recurso->areas()->attach($validated['area_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Área asociada correctamente.');
}
public function updateAreaPivot(Request $request, Recurso $recurso, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('area_recurso')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('area_recurso')
->where('recurso_id', $recurso->id)
->where('area_id', $registroActual->area_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para esta área.',
]);
}
}
DB::table('area_recurso')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachArea(Recurso $recurso, $pivotId)
{
DB::table('area_recurso')->where('recurso_id', $recurso->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de área eliminada correctamente.');
}
public function attachPerfil(Request $request, Recurso $recurso)
{
$validated = $request->validate([
'perfil_id' => ['required', 'exists:perfiles,id'],
'evidencia' => ['nullable', 'string'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'fecha_revision' => ['nullable', 'date'],
'fecha_proxima_revision' => ['nullable', 'date', 'after_or_equal:fecha_revision'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_recurso')
->where('recurso_id', $recurso->id)
->where('perfil_id', $validated['perfil_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para este perfil.',
]);
}
}
$recurso->perfiles()->attach($validated['perfil_id'], [
'evidencia' => $validated['evidencia'] ?? null,
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'fecha_revision' => $validated['fecha_revision'] ?? null,
'fecha_proxima_revision' => $validated['fecha_proxima_revision'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Perfil asociado correctamente.');
}
public function updatePerfilPivot(Request $request, Recurso $recurso, $pivotId)
{
$validated = $request->validate([
'evidencia' => ['nullable', 'string'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'fecha_revision' => ['nullable', 'date'],
'fecha_proxima_revision' => ['nullable', 'date', 'after_or_equal:fecha_revision'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('perfil_recurso')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_recurso')
->where('recurso_id', $recurso->id)
->where('perfil_id', $registroActual->perfil_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para este perfil.',
]);
}
}
DB::table('perfil_recurso')
->where('recurso_id', $recurso->id)
->where('id', $pivotId)
->update([
'evidencia' => $validated['evidencia'] ?? null,
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'fecha_revision' => $validated['fecha_revision'] ?? null,
'fecha_proxima_revision' => $validated['fecha_proxima_revision'] ?? null,
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachPerfil(Recurso $recurso, $pivotId)
{
DB::table('perfil_recurso')->where('recurso_id', $recurso->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de perfil eliminada correctamente.');
}
public function attachVulnerabilidad(Request $request, Recurso $recurso)
{
$validated = $request->validate([
'vulnerabilidad_id' => ['required', 'exists:vulnerabilidades,id'],
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_identificacion']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recursos_vulnerabilidad')
->where('recursos_id', $recurso->id)
->where('vulnerabilidad_id', $validated['vulnerabilidad_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_identificacion);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para esta vulnerabilidad.',
]);
}
}
$recurso->vulnerabilidades()->attach($validated['vulnerabilidad_id'], [
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Vulnerabilidad asociada correctamente.');
}
public function updateVulnerabilidadPivot(Request $request, Recurso $recurso, $pivotId)
{
$validated = $request->validate([
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('recursos_vulnerabilidad')
->where('recursos_id', $recurso->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_identificacion']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recursos_vulnerabilidad')
->where('recursos_id', $recurso->id)
->where('vulnerabilidad_id', $registroActual->vulnerabilidad_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_identificacion);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con un registro existente para esta vulnerabilidad.',
]);
}
}
DB::table('recursos_vulnerabilidad')
->where('recursos_id', $recurso->id)
->where('id', $pivotId)
->update([
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachVulnerabilidad(Recurso $recurso, $pivotId)
{
DB::table('recursos_vulnerabilidad')->where('recursos_id', $recurso->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de vulnerabilidad eliminada correctamente.');
}
}
+462
View File
@@ -0,0 +1,462 @@
<?php
namespace App\Http\Controllers;
use App\Models\Permiso;
use App\Models\Recurso;
use App\Models\Usuario;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Inertia\Inertia;
class ReporteController extends Controller
{
public function index(Request $request)
{
$request->validate([
'desde' => ['nullable', 'date'],
'hasta' => ['nullable', 'date', 'after_or_equal:desde'],
'dias' => ['nullable', 'integer', 'min:1', 'max:3650'],
]);
$usuarios = Usuario::with(['roles.perfiles.permisos', 'areas'])
->where('activo', true)
->get();
$matriz = [];
foreach ($usuarios as $usuario) {
foreach ($usuario->roles as $rol) {
if ($rol->pivot->fecha_fin && now()->greaterThan($rol->pivot->fecha_fin)) {
continue;
}
foreach ($rol->perfiles as $perfil) {
if ($perfil->pivot->fecha_fin && now()->greaterThan($perfil->pivot->fecha_fin)) {
continue;
}
foreach ($perfil->permisos as $permiso) {
if ($permiso->pivot->fecha_fin && now()->greaterThan($permiso->pivot->fecha_fin)) {
continue;
}
$matriz[] = [
'usuario_id' => $usuario->id,
'usuario_nombre' => $usuario->nombre.' '.$usuario->apellido,
'usuario_correo' => $usuario->correo,
'area_nombre' => $usuario->areas->first()?->nombre ?? 'Sin area',
'rol_nombre' => $rol->nombre,
'rol_vigente' => $rol->pivot->fecha_fin === null || now()->lte($rol->pivot->fecha_fin),
'perfil_nombre' => $perfil->nombre,
'permiso_nombre' => $permiso->nombre,
'permiso_accion' => $permiso->accion,
'fecha_inicio' => $permiso->pivot->fecha_inicio,
'fecha_fin' => $permiso->pivot->fecha_fin,
];
}
}
}
}
$permisos = Permiso::all();
$desde = $request->input('desde', now()->subDays(30)->toDateString());
$hasta = $request->input('hasta', now()->toDateString());
$nuevosPermisos = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_inicio')
->whereBetween('permiso_perfil.fecha_inicio', [$desde, $hasta])
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderByDesc('permiso_perfil.fecha_inicio')
->get();
$permisosBaja = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '<', now())
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderByDesc('permiso_perfil.fecha_fin')
->get();
$dias = (int) $request->input('dias', 30);
$permisosExpiran = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '>=', now())
->where('permiso_perfil.fecha_fin', '<=', now()->addDays($dias))
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderBy('permiso_perfil.fecha_fin', 'asc')
->get();
$activeTab = (int) $request->input('tab', 0);
return Inertia::render('Reportes/Index', [
'matriz' => $matriz,
'totalRegistros' => count($matriz),
'permisos' => $permisos,
'nuevosPermisos' => $nuevosPermisos,
'filtrosNuevos' => ['desde' => $desde, 'hasta' => $hasta],
'permisosBaja' => $permisosBaja,
'permisosExpiran' => $permisosExpiran,
'filtrosExpiran' => ['dias' => $dias],
'activeTab' => $activeTab,
'topUsuarios' => DB::table('recurso_usuario')
->join('usuarios', 'usuarios.id', '=', 'recurso_usuario.usuario_id')
->select('usuarios.id as usuario_id', DB::raw('CONCAT(usuarios.nombre, " ", usuarios.apellido) as usuario_nombre'), 'usuarios.correo', DB::raw('COUNT(DISTINCT recurso_usuario.recurso_id) as total_recursos'), DB::raw('SUM(CASE WHEN recurso_usuario.duenio = 1 THEN 1 ELSE 0 END) as total_duenio'))
->groupBy('usuarios.id', 'usuarios.nombre', 'usuarios.apellido', 'usuarios.correo')
->orderByDesc('total_recursos')->limit(10)->get(),
'topPerfiles' => DB::table('perfil_recurso')
->join('perfiles', 'perfiles.id', '=', 'perfil_recurso.perfil_id')
->select('perfiles.id as perfil_id', 'perfiles.nombre as perfil_nombre', DB::raw('COUNT(DISTINCT perfil_recurso.recurso_id) as total_recursos'), DB::raw('SUM(CASE WHEN perfil_recurso.fecha_fin IS NULL OR perfil_recurso.fecha_fin >= CURDATE() THEN 1 ELSE 0 END) as vigentes'), DB::raw('SUM(CASE WHEN perfil_recurso.fecha_fin IS NOT NULL AND perfil_recurso.fecha_fin < CURDATE() THEN 1 ELSE 0 END) as vencidos'))
->groupBy('perfiles.id', 'perfiles.nombre')
->orderByDesc('total_recursos')->get(),
'detalleAcceso' => DB::table('recurso_usuario')
->join('usuarios', 'usuarios.id', '=', 'recurso_usuario.usuario_id')
->join('recursos', 'recursos.id', '=', 'recurso_usuario.recurso_id')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->leftJoin('rol_usuario', 'rol_usuario.usuario_id', '=', 'usuarios.id')
->leftJoin('roles', 'roles.id', '=', 'rol_usuario.rol_id')
->select('usuarios.id as usuario_id', DB::raw('CONCAT(usuarios.nombre, " ", usuarios.apellido) as usuario_nombre'), 'usuarios.correo', 'recursos.nombre as recurso_nombre', 'tipos_recursos.nombre as tipo_recurso', 'roles.nombre as rol_nombre', 'recurso_usuario.duenio', 'recurso_usuario.activo', 'recurso_usuario.fecha_inicio', 'recurso_usuario.fecha_fin')
->orderBy('usuarios.nombre')->orderBy('recursos.nombre')->get(),
'recursosSinAsignar' => \App\Models\Recurso::doesntHave('usuarios')->select('id', 'nombre')->get(),
'recursosConPerfiles' => DB::table('recursos')
->leftJoin('perfil_recurso', 'recursos.id', '=', 'perfil_recurso.recurso_id')
->leftJoin('perfiles', 'perfiles.id', '=', 'perfil_recurso.perfil_id')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->select('recursos.id', 'recursos.nombre as recurso_nombre', 'tipos_recursos.nombre as tipo_recurso', DB::raw('GROUP_CONCAT(DISTINCT perfiles.nombre SEPARATOR ", ") as perfiles_asignados'), DB::raw('COUNT(DISTINCT perfiles.id) as total_perfiles'), DB::raw('SUM(CASE WHEN perfil_recurso.perfil_id IS NOT NULL AND (perfil_recurso.fecha_fin IS NULL OR perfil_recurso.fecha_fin >= CURDATE()) THEN 1 ELSE 0 END) as perfiles_vigentes'), DB::raw('SUM(CASE WHEN perfil_recurso.perfil_id IS NOT NULL AND perfil_recurso.fecha_fin IS NOT NULL AND perfil_recurso.fecha_fin < CURDATE() THEN 1 ELSE 0 END) as perfiles_vencidos'))
->groupBy('recursos.id', 'recursos.nombre', 'tipos_recursos.nombre')
->orderBy('recursos.nombre')->get(),
'recursosSinPerfil' => \App\Models\Recurso::doesntHave('perfiles')->select('id', 'nombre')->get(),
'distribucionTipos' => DB::table('recursos')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->select(DB::raw('COALESCE(tipos_recursos.nombre, "Sin tipo") as tipo'), DB::raw('COUNT(*) as total'))
->groupBy('tipo')->orderByDesc('total')->get(),
'matrizCobertura' => DB::table('recursos')
->crossJoin('perfiles')
->leftJoin('perfil_recurso', function ($join) {
$join->on('recursos.id', '=', 'perfil_recurso.recurso_id')
->on('perfiles.id', '=', 'perfil_recurso.perfil_id');
})
->select('recursos.nombre as recurso_nombre', 'perfiles.nombre as perfil_nombre', DB::raw('CASE WHEN perfil_recurso.id IS NOT NULL THEN 1 ELSE 0 END as asignado'), 'perfil_recurso.fecha_fin')
->orderBy('recursos.nombre')->orderBy('perfiles.nombre')->get(),
]);
}
public function permisosEfectivos()
{
$usuarios = Usuario::with(['roles.perfiles.permisos', 'areas'])
->where('activo', true)
->get();
$matriz = [];
foreach ($usuarios as $usuario) {
foreach ($usuario->roles as $rol) {
if ($rol->pivot->fecha_fin && now()->greaterThan($rol->pivot->fecha_fin)) {
continue;
}
foreach ($rol->perfiles as $perfil) {
if ($perfil->pivot->fecha_fin && now()->greaterThan($perfil->pivot->fecha_fin)) {
continue;
}
foreach ($perfil->permisos as $permiso) {
if ($permiso->pivot->fecha_fin && now()->greaterThan($permiso->pivot->fecha_fin)) {
continue;
}
$matriz[] = [
'usuario_id' => $usuario->id,
'usuario_nombre' => $usuario->nombre.' '.$usuario->apellido,
'usuario_correo' => $usuario->correo,
'area_nombre' => $usuario->areas->first()?->nombre ?? 'Sin area',
'rol_nombre' => $rol->nombre,
'rol_vigente' => $rol->pivot->fecha_fin === null || now()->lte($rol->pivot->fecha_fin),
'perfil_nombre' => $perfil->nombre,
'permiso_nombre' => $permiso->nombre,
'permiso_accion' => $permiso->accion,
'fecha_inicio' => $permiso->pivot->fecha_inicio,
'fecha_fin' => $permiso->pivot->fecha_fin,
];
}
}
}
}
$permisos = Permiso::all();
return Inertia::render('Reportes/PermisosEfectivos', [
'matriz' => $matriz,
'totalRegistros' => count($matriz),
'permisos' => $permisos,
]);
}
public function permisosNuevos(Request $request)
{
$request->validate([
'desde' => ['nullable', 'date'],
'hasta' => ['nullable', 'date', 'after_or_equal:desde'],
]);
$desde = $request->input('desde', now()->subDays(30)->toDateString());
$hasta = $request->input('hasta', now()->toDateString());
$nuevosPermisos = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_inicio')
->whereBetween('permiso_perfil.fecha_inicio', [$desde, $hasta])
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderByDesc('permiso_perfil.fecha_inicio')
->get();
return Inertia::render('Reportes/PermisosNuevos', [
'nuevosPermisos' => $nuevosPermisos,
'filtros' => ['desde' => $desde, 'hasta' => $hasta],
]);
}
public function permisosBaja(Request $request)
{
$permisosBaja = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '<', now())
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderByDesc('permiso_perfil.fecha_fin')
->get();
return Inertia::render('Reportes/PermisosBaja', [
'permisosBaja' => $permisosBaja,
]);
}
public function permisosExpiran(Request $request)
{
$request->validate([
'dias' => ['nullable', 'integer', 'min:1', 'max:3650'],
]);
$dias = (int) $request->input('dias', 30);
$permisosExpiran = DB::table('permiso_perfil')
->join('permisos', 'permisos.id', '=', 'permiso_perfil.permiso_id')
->join('perfiles', 'perfiles.id', '=', 'permiso_perfil.perfil_id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'perfiles.id')
->join('roles', 'roles.id', '=', 'perfil_rol.rol_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'roles.id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '>=', now())
->where('permiso_perfil.fecha_fin', '<=', now()->addDays($dias))
->select(
'permisos.nombre as permiso_nombre',
'permisos.accion',
'perfiles.nombre as perfil_nombre',
'roles.nombre as rol_nombre',
'usuarios.nombre as usuario_nombre',
'usuarios.apellido as usuario_apellido',
'usuarios.correo',
'permiso_perfil.fecha_inicio',
'permiso_perfil.fecha_fin'
)
->orderBy('permiso_perfil.fecha_fin', 'asc')
->get();
return Inertia::render('Reportes/PermisosExpiran', [
'permisosExpiran' => $permisosExpiran,
'filtros' => ['dias' => $dias],
]);
}
public function accesoRecursos()
{
$topUsuarios = DB::table('recurso_usuario')
->join('usuarios', 'usuarios.id', '=', 'recurso_usuario.usuario_id')
->join('recursos', 'recursos.id', '=', 'recurso_usuario.recurso_id')
->select(
'usuarios.id as usuario_id',
DB::raw('CONCAT(usuarios.nombre, " ", usuarios.apellido) as usuario_nombre'),
'usuarios.correo',
DB::raw('COUNT(DISTINCT recurso_usuario.recurso_id) as total_recursos'),
DB::raw('SUM(CASE WHEN recurso_usuario.duenio = 1 THEN 1 ELSE 0 END) as total_duenio')
)
->groupBy('usuarios.id', 'usuarios.nombre', 'usuarios.apellido', 'usuarios.correo')
->orderByDesc('total_recursos')
->limit(10)
->get();
$topPerfiles = DB::table('perfil_recurso')
->join('perfiles', 'perfiles.id', '=', 'perfil_recurso.perfil_id')
->join('recursos', 'recursos.id', '=', 'perfil_recurso.recurso_id')
->select(
'perfiles.id as perfil_id',
'perfiles.nombre as perfil_nombre',
DB::raw('COUNT(DISTINCT perfil_recurso.recurso_id) as total_recursos'),
DB::raw('SUM(CASE WHEN perfil_recurso.fecha_fin IS NULL OR perfil_recurso.fecha_fin >= CURDATE() THEN 1 ELSE 0 END) as vigentes'),
DB::raw('SUM(CASE WHEN perfil_recurso.fecha_fin IS NOT NULL AND perfil_recurso.fecha_fin < CURDATE() THEN 1 ELSE 0 END) as vencidos')
)
->groupBy('perfiles.id', 'perfiles.nombre')
->orderByDesc('total_recursos')
->get();
$detalleAcceso = DB::table('recurso_usuario')
->join('usuarios', 'usuarios.id', '=', 'recurso_usuario.usuario_id')
->join('recursos', 'recursos.id', '=', 'recurso_usuario.recurso_id')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->leftJoin('rol_usuario', 'rol_usuario.usuario_id', '=', 'usuarios.id')
->leftJoin('roles', 'roles.id', '=', 'rol_usuario.rol_id')
->select(
'usuarios.id as usuario_id',
DB::raw('CONCAT(usuarios.nombre, " ", usuarios.apellido) as usuario_nombre'),
'usuarios.correo',
'recursos.nombre as recurso_nombre',
'tipos_recursos.nombre as tipo_recurso',
'roles.nombre as rol_nombre',
'recurso_usuario.duenio',
'recurso_usuario.activo',
'recurso_usuario.fecha_inicio',
'recurso_usuario.fecha_fin'
)
->orderBy('usuarios.nombre')
->orderBy('recursos.nombre')
->get();
$recursosSinAsignar = Recurso::doesntHave('usuarios')
->select('id', 'nombre')
->get();
return Inertia::render('Reportes/AccesoRecursos', [
'topUsuarios' => $topUsuarios,
'topPerfiles' => $topPerfiles,
'detalleAcceso' => $detalleAcceso,
'recursosSinAsignar' => $recursosSinAsignar,
]);
}
public function relacionesCobertura()
{
$recursosConPerfiles = DB::table('recursos')
->leftJoin('perfil_recurso', 'recursos.id', '=', 'perfil_recurso.recurso_id')
->leftJoin('perfiles', 'perfiles.id', '=', 'perfil_recurso.perfil_id')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->select(
'recursos.id',
'recursos.nombre as recurso_nombre',
'tipos_recursos.nombre as tipo_recurso',
DB::raw('GROUP_CONCAT(DISTINCT perfiles.nombre SEPARATOR ", ") as perfiles_asignados'),
DB::raw('COUNT(DISTINCT perfiles.id) as total_perfiles'),
DB::raw('SUM(CASE WHEN perfil_recurso.perfil_id IS NOT NULL AND (perfil_recurso.fecha_fin IS NULL OR perfil_recurso.fecha_fin >= CURDATE()) THEN 1 ELSE 0 END) as perfiles_vigentes'),
DB::raw('SUM(CASE WHEN perfil_recurso.perfil_id IS NOT NULL AND perfil_recurso.fecha_fin IS NOT NULL AND perfil_recurso.fecha_fin < CURDATE() THEN 1 ELSE 0 END) as perfiles_vencidos')
)
->groupBy('recursos.id', 'recursos.nombre', 'tipos_recursos.nombre')
->orderBy('recursos.nombre')
->get();
$recursosSinPerfil = Recurso::doesntHave('perfiles')
->select('id', 'nombre')
->get();
$distribucionTipos = DB::table('recursos')
->leftJoin('tipos_recursos', 'tipos_recursos.id', '=', 'recursos.tipo_recurso_id')
->select(
DB::raw('COALESCE(tipos_recursos.nombre, "Sin tipo") as tipo'),
DB::raw('COUNT(*) as total')
)
->groupBy('tipo')
->orderByDesc('total')
->get();
$matrizCobertura = DB::table('recursos')
->crossJoin('perfiles')
->leftJoin('perfil_recurso', function ($join) {
$join->on('recursos.id', '=', 'perfil_recurso.recurso_id')
->on('perfiles.id', '=', 'perfil_recurso.perfil_id');
})
->select(
'recursos.nombre as recurso_nombre',
'perfiles.nombre as perfil_nombre',
DB::raw('CASE WHEN perfil_recurso.id IS NOT NULL THEN 1 ELSE 0 END as asignado'),
'perfil_recurso.fecha_fin'
)
->orderBy('recursos.nombre')
->orderBy('perfiles.nombre')
->get();
return Inertia::render('Reportes/RelacionesCobertura', [
'recursosConPerfiles' => $recursosConPerfiles,
'recursosSinPerfil' => $recursosSinPerfil,
'distribucionTipos' => $distribucionTipos,
'matrizCobertura' => $matrizCobertura,
]);
}
}
+89
View File
@@ -0,0 +1,89 @@
<?php
namespace App\Http\Controllers;
use App\Http\Requests\StoreRiesgoRequest;
use App\Models\Amenaza;
use App\Models\Recurso;
use App\Models\Riesgo;
use App\Models\Vulnerabilidad;
use App\Support\RiskCalculator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class RiesgoController extends Controller
{
private function applyFilters(Builder $query, Request $request): Builder
{
$search = trim((string) $request->input('search'));
if ($search !== '') {
$query->where(function (Builder $query) use ($search): void {
$query->where('nombre', 'like', "%{$search}%")
->orWhere('descripcion', 'like', "%{$search}%")
->orWhere('riesgo_inherente', 'like', "%{$search}%")
->orWhere('riesgo_residual', 'like', "%{$search}%")
->orWhereHas('recurso', fn (Builder $related) => $related->where('nombre', 'like', "%{$search}%"))
->orWhereHas('amenaza', fn (Builder $related) => $related->where('nombre', 'like', "%{$search}%"))
->orWhereHas('vulnerabilidad', fn (Builder $related) => $related->where('nombre', 'like', "%{$search}%"));
});
}
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
foreach (['riesgo_inherente', 'riesgo_residual', 'recursos_id', 'amenazas_id', 'vulnerabilidades_id'] as $field) {
if ($request->filled($field)) {
$query->where($field, $request->input($field));
}
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'riesgo_inherente', 'riesgo_residual', 'recursos_id', 'amenazas_id', 'vulnerabilidades_id'];
$query = Riesgo::with(['recurso', 'amenaza', 'vulnerabilidad']);
$this->applyFilters($query, $request);
$levelOptions = collect(Riesgo::NIVELES)->map(fn (string $nivel) => ['value' => $nivel, 'label' => $nivel]);
return Inertia::render('Riesgos/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'niveles' => $levelOptions,
'recursos' => Recurso::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
'amenazas' => Amenaza::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
'vulnerabilidades' => Vulnerabilidad::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
],
]);
}
public function create()
{
return Inertia::render('Riesgos/Create', [
'recursos' => Recurso::select('id', 'nombre')->orderBy('nombre')->get(),
'amenazas' => Amenaza::select('id', 'nombre')->orderBy('nombre')->get(),
'vulnerabilidades' => Vulnerabilidad::select('id', 'nombre')->orderBy('nombre')->get(),
]);
}
public function store(StoreRiesgoRequest $request)
{
$riesgo = Riesgo::create($request->validated());
RiskCalculator::recalculate($riesgo);
return redirect()->route('riesgos.index')->with('success', 'Riesgo creado exitosamente.');
}
public function destroy(Riesgo $riesgo)
{
$this->deletePreservingHistory($riesgo);
return redirect()->route('riesgos.index')->with('success', 'Riesgo eliminado exitosamente.');
}
}
@@ -0,0 +1,180 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\Control;
use App\Models\Recurso;
use App\Models\Riesgo;
use App\Models\Vulnerabilidad;
use App\Support\HistoricalPeriod;
use App\Support\RiskCalculator;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
class RiesgoGestionController extends Controller
{
public function show(Riesgo $riesgo)
{
$riesgo->load(['recurso', 'amenaza', 'vulnerabilidad', 'controles']);
$calculation = RiskCalculator::calculate($riesgo);
return Inertia::render('Riesgos/Gestionar', [
'riesgo' => $riesgo,
'niveles' => Riesgo::NIVELES,
'recursos' => Recurso::select('id', 'nombre')->orderBy('nombre')->get(),
'amenazas' => Amenaza::select('id', 'nombre')->orderBy('nombre')->get(),
'vulnerabilidades' => Vulnerabilidad::select('id', 'nombre')->orderBy('nombre')->get(),
'controles' => Control::orderBy('nombre')->get(),
'calculation' => $calculation,
]);
}
public function updateField(Request $request, Riesgo $riesgo)
{
$editableFields = [
'nombre', 'descripcion', 'fecha_alta', 'fecha_baja',
'recursos_id', 'amenazas_id', 'vulnerabilidades_id',
];
$validated = $request->validate([
'field' => ['required', Rule::in($editableFields)],
'value' => ['nullable'],
]);
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date'],
'recursos_id' => ['required', 'integer', 'exists:recursos,id'],
'amenazas_id' => ['required', 'integer', 'exists:amenazas,id'],
'vulnerabilidades_id' => ['required', 'integer', 'exists:vulnerabilidades,id'],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
$fechaAlta = $validated['field'] === 'fecha_alta' ? Carbon::parse($value) : $riesgo->fecha_alta;
$fechaBaja = $validated['field'] === 'fecha_baja' && $value
? Carbon::parse($value)
: ($validated['field'] === 'fecha_baja' ? null : $riesgo->fecha_baja);
if ($fechaAlta && $fechaBaja && $fechaBaja->lt($fechaAlta)) {
throw ValidationException::withMessages(['value' => 'La baja no puede ser anterior al alta.']);
}
$riesgo->update([$validated['field'] => $value]);
RiskCalculator::recalculate($riesgo);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachControl(Request $request, Riesgo $riesgo)
{
$validated = $request->validate([
'control_id' => ['required', 'integer', 'exists:controles,id'],
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$this->ensurePeriodDoesNotOverlap(
$riesgo->id,
(int) $validated['control_id'],
$validated['fecha_identificacion'],
$validated['fecha_fin'],
);
$riesgo->controles()->attach($validated['control_id'], [
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'],
]);
RiskCalculator::recalculate($riesgo);
return back()->with('success', 'Control asociado correctamente.');
}
public function updateControlPivot(Request $request, Riesgo $riesgo, int $pivotId)
{
$validated = $request->validate([
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$pivot = DB::table('riesgo_control')
->where('riesgo_id', $riesgo->id)
->where('id', $pivotId)
->firstOrFail();
$this->ensurePeriodDoesNotOverlap(
$riesgo->id,
(int) $pivot->control_id,
$validated['fecha_identificacion'],
$validated['fecha_fin'],
$pivotId,
);
DB::table('riesgo_control')
->where('riesgo_id', $riesgo->id)
->where('id', $pivotId)
->update([
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
RiskCalculator::recalculate($riesgo);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function detachControl(Riesgo $riesgo, int $pivotId)
{
DB::table('riesgo_control')->where('riesgo_id', $riesgo->id)->where('id', $pivotId)->delete();
RiskCalculator::recalculate($riesgo);
return back()->with('success', 'Asignación de control eliminada correctamente.');
}
private function ensurePeriodDoesNotOverlap(
int $riesgoId,
int $controlId,
string $start,
?string $end,
?int $excludedPivotId = null,
): void {
$periods = DB::table('riesgo_control')
->where('riesgo_id', $riesgoId)
->where('control_id', $controlId)
->when($excludedPivotId, fn ($query) => $query->where('id', '!=', $excludedPivotId))
->get();
$startDate = Carbon::parse($start);
$endDate = $end ? Carbon::parse($end) : null;
foreach ($periods as $period) {
$otherStart = Carbon::parse($period->fecha_identificacion);
$otherEnd = $period->fecha_fin ? Carbon::parse($period->fecha_fin) : null;
$startsBeforeOtherEnds = $otherEnd === null || $startDate->lte($otherEnd);
$endsAfterOtherStarts = $endDate === null || $endDate->gte($otherStart);
if ($startsBeforeOtherEnds && $endsAfterOtherStarts) {
throw ValidationException::withMessages([
'fecha_identificacion' => 'Las fechas chocan con una asignación existente.',
]);
}
}
}
}
+129
View File
@@ -0,0 +1,129 @@
<?php
namespace App\Http\Controllers;
use App\Models\Rol;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class RolController extends Controller
{
private function applyRolFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
if ($request->input('vigencia') === 'vigente') {
$query->where(function (Builder $query): void {
$query->whereNull('fecha_inicio')->orWhereDate('fecha_inicio', '<=', today());
});
$query->where(function (Builder $query): void {
$query->whereNull('fecha_fin')->orWhereDate('fecha_fin', '>=', today());
});
} elseif ($request->input('vigencia') === 'vencido') {
$query->whereDate('fecha_fin', '<', today());
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'vigencia'];
$query = Rol::query();
$this->applyRolFilters($query, $request);
return Inertia::render('Roles/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'vigencias' => [
['value' => 'vigente', 'label' => 'Vigente'],
['value' => 'vencido', 'label' => 'Vencido'],
],
],
]);
}
public function export(Request $request)
{
$query = Rol::query();
$this->applyRolFilters($query, $request);
$items = $query->get();
$fileName = 'roles_'.now()->format('Ymd_His').'.csv';
$columns = ['ID', 'Nombre', 'Descripción', 'Fecha Inicio', 'Fecha Fin'];
return $this->streamCsv($fileName, $columns, $items, fn ($item) => [
$item->id,
$item->nombre,
$item->descripcion,
$item->fecha_inicio,
$item->fecha_fin,
]);
}
public function create()
{
return Inertia::render('Roles/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'fecha_inicio' => 'nullable|date',
'fecha_fin' => 'nullable|date|after_or_equal:fecha_inicio',
]);
Rol::create($validated);
return redirect()->route('roles.index')->with('success', 'Rol creado exitosamente.');
}
public function edit(Rol $rol)
{
return Inertia::render('Roles/Edit', [
'item' => $rol,
'isGestionar' => false,
]);
}
public function gestionar(Rol $rol)
{
return Inertia::render('Roles/Edit', [
'item' => $rol,
'isGestionar' => true,
]);
}
public function update(Request $request, Rol $rol)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
'fecha_inicio' => 'nullable|date',
'fecha_fin' => 'nullable|date|after_or_equal:fecha_inicio',
]);
$rol->update($validated);
return redirect()->route('roles.index')->with('success', 'Rol actualizado exitosamente.');
}
public function destroy(Rol $rol)
{
$this->deletePreservingHistory($rol);
return redirect()->route('roles.index')->with('success', 'Rol eliminado exitosamente.');
}
}
@@ -0,0 +1,257 @@
<?php
namespace App\Http\Controllers;
use App\Models\Perfil;
use App\Models\Rol;
use App\Models\Usuario;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class RolGestionController extends Controller
{
public function show(Rol $rol)
{
return Inertia::render('Roles/Gestionar', [
'rol' => $rol->load(['usuarios', 'perfiles']),
'usuarios' => Usuario::query()->where('activo', true)->orderBy('nombre')->get(),
'perfiles' => Perfil::query()->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Rol $rol)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin'])],
'value' => ['nullable'],
]);
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'fecha_inicio' => ['nullable', 'date'],
'fecha_fin' => ['nullable', 'date'],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
if (in_array($validated['field'], ['fecha_inicio', 'fecha_fin'], true)) {
validator([
'fecha_inicio' => $validated['field'] === 'fecha_inicio' ? $value : $rol->fecha_inicio,
'fecha_fin' => $validated['field'] === 'fecha_fin' ? $value : $rol->fecha_fin,
], [
'fecha_inicio' => ['nullable', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
])->validate();
}
$rol->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachUsuario(Request $request, Rol $rol)
{
$validated = $request->validate([
'usuario_id' => ['required', 'exists:usuarios,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('rol_usuario')
->where('rol_id', $rol->id)
->where('usuario_id', $validated['usuario_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con otro registro existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
$rol->usuarios()->attach($validated['usuario_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Usuario asociado correctamente.');
}
public function detachUsuario(Rol $rol, $pivotId)
{
DB::table('rol_usuario')->where('rol_id', $rol->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación eliminada correctamente.');
}
public function updateUsuarioPivot(Request $request, Rol $rol, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('rol_usuario')
->where('rol_id', $rol->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('rol_usuario')
->where('rol_id', $rol->id)
->where('usuario_id', $registroActual->usuario_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeQueTermineElOtro = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespuesDeQueEmpieceElOtro = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntesDeQueTermineElOtro && $terminaDespuesDeQueEmpieceElOtro) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con otro registro existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
DB::table('rol_usuario')
->where('rol_id', $rol->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function attachPerfil(Request $request, Rol $rol)
{
$validated = $request->validate([
'perfil_id' => ['required', 'exists:perfiles,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_rol')
->where('rol_id', $rol->id)
->where('perfil_id', $validated['perfil_id'])
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntes = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespues = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntes && $terminaDespues) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con otro registro existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
$rol->perfiles()->attach($validated['perfil_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Perfil asociado correctamente.');
}
public function detachPerfil(Rol $rol, $pivotId)
{
DB::table('perfil_rol')->where('rol_id', $rol->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación eliminada correctamente.');
}
public function updatePerfilPivot(Request $request, Rol $rol, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], [
'fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la fecha de inicio.',
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('perfil_rol')
->where('rol_id', $rol->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('perfil_rol')
->where('rol_id', $rol->id)
->where('perfil_id', $registroActual->perfil_id)
->where('id', '!=', $pivotId)
->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeQueTermineElOtro = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespuesDeQueEmpieceElOtro = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntesDeQueTermineElOtro && $terminaDespuesDeQueEmpieceElOtro) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw \Illuminate\Validation\ValidationException::withMessages([
'fecha_inicio' => 'Las fechas chocan con otro registro existente.',
]);
}
}
DB::table('perfil_rol')
->where('rol_id', $rol->id)
->where('id', $pivotId)
->update([
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'updated_at' => now(),
]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
}
@@ -0,0 +1,43 @@
<?php
namespace App\Http\Controllers;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
use Spatie\Permission\Models\Role;
class SeguridadUsuarioController extends Controller
{
public function index()
{
return Inertia::render('Seguridad/Usuarios', [
'usuariosSistema' => User::with('roles:id,name')
->orderBy('name')
->get(['id', 'name', 'email'])
->map(fn (User $user) => [
'id' => $user->id,
'name' => $user->name,
'email' => $user->email,
'rol' => $user->roles->first()?->name,
]),
'rolesDisponibles' => Role::orderBy('name')->pluck('name'),
]);
}
public function updateRol(Request $request, User $user)
{
$validated = $request->validate([
'rol' => ['required', 'string', Rule::exists('auth_roles', 'name')->where('guard_name', 'web')],
]);
if ($user->is($request->user()) && $validated['rol'] !== 'administrador') {
return back()->with('error', 'No podés quitarte a vos mismo el rol de administrador.');
}
$user->syncRoles([$validated['rol']]);
return back()->with('success', 'Rol actualizado exitosamente.');
}
}
@@ -0,0 +1,80 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoAmenaza;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class TipoAmenazaController extends Controller
{
private function applyTipoAmenazaFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion'];
$query = TipoAmenaza::query();
$this->applyTipoAmenazaFilters($query, $request);
return Inertia::render('TiposAmenazas/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
]);
}
public function create()
{
return Inertia::render('TiposAmenazas/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
TipoAmenaza::create($validated);
return redirect()->route('tipos-amenazas.index')->with('success', 'Tipo de amenaza creado exitosamente.');
}
public function edit(TipoAmenaza $tipoAmenaza)
{
return Inertia::render('TiposAmenazas/Edit', [
'tipo' => $tipoAmenaza,
]);
}
public function update(Request $request, TipoAmenaza $tipoAmenaza)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
$tipoAmenaza->update($validated);
return redirect()->route('tipos-amenazas.index')->with('success', 'Tipo de amenaza actualizado exitosamente.');
}
public function destroy(TipoAmenaza $tipoAmenaza)
{
$this->deletePreservingHistory($tipoAmenaza);
return redirect()->route('tipos-amenazas.index')->with('success', 'Tipo de amenaza eliminado exitosamente.');
}
}
@@ -0,0 +1,80 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoControl;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class TipoControlController extends Controller
{
private function applyTipoControlFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion'];
$query = TipoControl::query();
$this->applyTipoControlFilters($query, $request);
return Inertia::render('TiposControles/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
]);
}
public function create()
{
return Inertia::render('TiposControles/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
TipoControl::create($validated);
return redirect()->route('tipos-controles.index')->with('success', 'Tipo de control creado exitosamente.');
}
public function edit(TipoControl $tipoControl)
{
return Inertia::render('TiposControles/Edit', [
'tipo' => $tipoControl,
]);
}
public function update(Request $request, TipoControl $tipoControl)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
$tipoControl->update($validated);
return redirect()->route('tipos-controles.index')->with('success', 'Tipo de control actualizado exitosamente.');
}
public function destroy(TipoControl $tipoControl)
{
$this->deletePreservingHistory($tipoControl);
return redirect()->route('tipos-controles.index')->with('success', 'Tipo de control eliminado exitosamente.');
}
}
@@ -0,0 +1,80 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoRecurso;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class TipoRecursoController extends Controller
{
private function applyTipoRecursoFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion'];
$query = TipoRecurso::query();
$this->applyTipoRecursoFilters($query, $request);
return Inertia::render('TiposRecursos/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
]);
}
public function create()
{
return Inertia::render('TiposRecursos/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
TipoRecurso::create($validated);
return redirect()->route('tipos-recursos.index')->with('success', 'Tipo de recurso creado exitosamente.');
}
public function edit(TipoRecurso $tipoRecurso)
{
return Inertia::render('TiposRecursos/Edit', [
'tipo' => $tipoRecurso,
]);
}
public function update(Request $request, TipoRecurso $tipoRecurso)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
$tipoRecurso->update($validated);
return redirect()->route('tipos-recursos.index')->with('success', 'Tipo de recurso actualizado exitosamente.');
}
public function destroy(TipoRecurso $tipoRecurso)
{
$this->deletePreservingHistory($tipoRecurso);
return redirect()->route('tipos-recursos.index')->with('success', 'Tipo de recurso eliminado exitosamente.');
}
}
@@ -0,0 +1,80 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoUsuario;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class TipoUsuarioController extends Controller
{
private function applyTipoUsuarioFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion'];
$query = TipoUsuario::query();
$this->applyTipoUsuarioFilters($query, $request);
return Inertia::render('TiposUsuarios/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
]);
}
public function create()
{
return Inertia::render('TiposUsuarios/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
TipoUsuario::create($validated);
return redirect()->route('tipos-usuarios.index')->with('success', 'Tipo de usuario creado exitosamente.');
}
public function edit(TipoUsuario $tipoUsuario)
{
return Inertia::render('TiposUsuarios/Edit', [
'tipo' => $tipoUsuario,
]);
}
public function update(Request $request, TipoUsuario $tipoUsuario)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
$tipoUsuario->update($validated);
return redirect()->route('tipos-usuarios.index')->with('success', 'Tipo de usuario actualizado exitosamente.');
}
public function destroy(TipoUsuario $tipoUsuario)
{
$this->deletePreservingHistory($tipoUsuario);
return redirect()->route('tipos-usuarios.index')->with('success', 'Tipo de usuario eliminado exitosamente.');
}
}
@@ -0,0 +1,61 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoVulnerabilidad;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class TipoVulnerabilidadController extends Controller
{
private function applyTipoVulnerabilidadFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion']);
if ($request->filled('nombre')) {
$query->where('nombre', 'like', '%'.trim((string) $request->input('nombre')).'%');
}
if ($request->filled('descripcion')) {
$query->where('descripcion', 'like', '%'.trim((string) $request->input('descripcion')).'%');
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion'];
$query = TipoVulnerabilidad::query();
$this->applyTipoVulnerabilidadFilters($query, $request);
return Inertia::render('TiposVulnerabilidades/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
]);
}
public function create()
{
return Inertia::render('TiposVulnerabilidades/Create');
}
public function store(Request $request)
{
$validated = $request->validate([
'nombre' => 'required|string|max:35',
'descripcion' => 'nullable|string|max:185',
]);
TipoVulnerabilidad::create($validated);
return redirect()->route('tipos-vulnerabilidades.index')->with('success', 'Tipo de vulnerabilidad creado exitosamente.');
}
public function destroy(TipoVulnerabilidad $tipoVulnerabilidad)
{
$this->deletePreservingHistory($tipoVulnerabilidad);
return redirect()->route('tipos-vulnerabilidades.index')->with('success', 'Tipo de vulnerabilidad eliminado exitosamente.');
}
}
+142
View File
@@ -0,0 +1,142 @@
<?php
namespace App\Http\Controllers;
use App\Models\TipoUsuario;
use App\Models\Usuario;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class UsuarioController extends Controller
{
private function applyUsuarioFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), [
'nombre', 'apellido', 'correo', 'documento', 'telefono',
]);
foreach (['documento', 'apellido', 'nombre', 'correo'] as $field) {
if ($request->filled($field)) {
$query->where($field, 'like', '%'.trim((string) $request->input($field)).'%');
}
}
if ($request->filled('tipo_usuario_id')) {
$query->where('tipo_usuario_id', $request->input('tipo_usuario_id'));
}
if ($request->input('activo') !== null && $request->input('activo') !== '') {
$query->where('activo', $request->boolean('activo'));
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'apellido', 'documento', 'correo', 'tipo_usuario_id', 'activo'];
$query = Usuario::with(['tipoUsuario', 'areas', 'roles']);
$this->applyUsuarioFilters($query, $request);
return Inertia::render('Usuarios/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'tiposUsuarios' => TipoUsuario::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
'activos' => [
['value' => '1', 'label' => 'Sí'],
['value' => '0', 'label' => 'No'],
],
],
]);
}
public function export(Request $request)
{
$query = Usuario::query();
$this->applyUsuarioFilters($query, $request);
return $this->streamCsv(
'usuarios_'.now()->format('Ymd_His').'.csv',
['ID', 'Nombre', 'Apellido', 'Correo', 'Documento', 'Teléfono', 'Activo', 'Fecha Alta', 'Fecha Baja'],
$query->get(),
fn ($item) => [
$item->id,
$item->nombre,
$item->apellido,
$item->correo,
$item->documento,
$item->telefono,
$item->activo ? 'Sí' : 'No',
$item->fecha_alta ? Carbon::parse($item->fecha_alta)->format('d/m/Y') : '-',
$item->fecha_baja ? Carbon::parse($item->fecha_baja)->format('d/m/Y') : '-',
],
);
}
public function create()
{
return Inertia::render('Usuarios/Create', [
'tipos_usuarios' => TipoUsuario::query()->orderBy('nombre')->get(),
]);
}
public function store(Request $request)
{
$usuario = Usuario::create($this->validateUsuario($request));
return redirect()->route('usuarios.gestionar', $usuario)->with('success', 'Usuario creado exitosamente.');
}
public function update(Request $request, Usuario $usuario)
{
$usuario->update($this->validateUsuario($request, $usuario));
return redirect()->route('usuarios.gestionar', $usuario)->with('success', 'Usuario actualizado exitosamente.');
}
public function destroy(Usuario $usuario)
{
$this->deletePreservingHistory($usuario);
return redirect()->route('usuarios.index')->with('success', 'Usuario eliminado exitosamente.');
}
public function obtenerUsuario(Request $request)
{
$request->validate([
'documento' => ['nullable', 'string'],
'apellido' => ['nullable', 'string'],
'nombre' => ['nullable', 'string'],
]);
if (! $request->filled('documento') && ! $request->filled('apellido') && ! $request->filled('nombre')) {
return response()->json([]);
}
$filtros = (object) [
'documento' => $request->input('documento'),
'apellido' => $request->input('apellido'),
'nombre' => $request->input('nombre'),
];
return response()->json(Usuario::buscar($filtros));
}
private function validateUsuario(Request $request, ?Usuario $usuario = null): array
{
return $request->validate([
'nombre' => ['required', 'string', 'max:35'],
'apellido' => ['required', 'string', 'max:35'],
'documento' => ['required', 'string', 'max:20'],
'correo' => ['required', 'regex:/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i', 'max:35', Rule::unique('usuarios', 'correo')->ignore($usuario?->id)],
'tipo_usuario_id' => ['required', 'exists:tipos_usuarios,id'],
'telefono' => ['nullable', 'string', 'regex:/^[0-9]*$/', 'max:16'],
'activo' => ['nullable', 'boolean'],
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
]);
}
}
@@ -0,0 +1,306 @@
<?php
namespace App\Http\Controllers;
use App\Models\Area;
use App\Models\Recurso;
use App\Models\Rol;
use App\Models\TipoUsuario;
use App\Models\Usuario;
use App\Support\HistoricalPeriod;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Inertia\Inertia;
class UsuarioGestionController extends Controller
{
public function show(Usuario $usuario)
{
return Inertia::render('Usuarios/Gestionar', [
'usuario' => $usuario->load([
'tipoUsuario',
'areas',
'roles',
'recursos.tipoRecurso',
]),
'areas' => Area::query()->orderBy('nombre')->get(),
'roles' => Rol::query()->orderBy('nombre')->get(),
'recursos' => Recurso::query()->with('tipoRecurso')->orderBy('nombre')->get(),
'tiposUsuario' => TipoUsuario::query()->orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Usuario $usuario)
{
$validated = $request->validate([
'field' => ['required', Rule::in([
'nombre_apellido', 'nombre', 'apellido', 'documento', 'correo', 'tipo_usuario_id',
'telefono', 'activo', 'fecha_alta', 'fecha_baja',
])],
'value' => ['nullable'],
]);
if ($validated['field'] === 'nombre_apellido') {
$values = validator($validated['value'] ?? [], [
'nombre' => ['required', 'string', 'max:35'],
'apellido' => ['required', 'string', 'max:35'],
])->validate();
$usuario->update($values);
return back()->with('success', 'Dato actualizado correctamente.');
}
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'apellido' => ['required', 'string', 'max:35'],
'documento' => ['required', 'string', 'max:20'],
'telefono' => ['nullable', 'string', 'regex:/^[0-9]*$/', 'max:16'],
'correo' => ['required', 'regex:/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/i', 'max:35', Rule::unique('usuarios', 'correo')->ignore($usuario->id)],
'tipo_usuario_id' => ['required', 'exists:tipos_usuarios,id'],
'activo' => ['nullable', 'boolean'],
];
if (array_key_exists($validated['field'], $rules)) {
$value = validator(['value' => $validated['value']], ['value' => $rules[$validated['field']]])->validate()['value'];
$usuario->update([$validated['field'] => $value]);
return back()->with('success', 'Dato actualizado correctamente.');
}
if (in_array($validated['field'], ['fecha_alta', 'fecha_baja'])) {
$fechas = [
'fecha_alta' => $validated['field'] === 'fecha_alta' ? $validated['value'] : $usuario->fecha_alta,
'fecha_baja' => $validated['field'] === 'fecha_baja' ? $validated['value'] : $usuario->fecha_baja,
];
$validator = \Illuminate\Support\Facades\Validator::make($fechas, [
'fecha_alta' => ['nullable', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
], [
'fecha_baja.after_or_equal' => 'La fecha de baja no puede ser anterior a la fecha de alta.',
]);
if ($validator->fails()) {
throw ValidationException::withMessages(['value' => $validator->errors()->first()]);
}
$usuario->update([$validated['field'] => $validated['value']]);
return back()->with('success', 'Fecha actualizada correctamente.');
}
}
private function checkOverlap($table, $usuarioId, $foreignKey, $foreignId, $inicioStr, $finStr, $excludePivotId = null)
{
$inicio = Carbon::parse($inicioStr);
$fin = $finStr ? Carbon::parse($finStr) : null;
$query = DB::table($table)
->where('usuario_id', $usuarioId)
->where($foreignKey, $foreignId);
if ($excludePivotId) {
$query->where('id', '!=', $excludePivotId);
}
$registros = $query->get();
foreach ($registros as $otro) {
if (! $otro->fecha_inicio) {
continue;
}
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
$empiezaAntesDeTerminar = $otroFin === null ? true : $inicio->lte($otroFin);
$terminaDespuesDeEmpezar = $fin === null ? true : $fin->gte($otroInicio);
if ($empiezaAntesDeTerminar && $terminaDespuesDeEmpezar) {
$textoOtroFin = $otroFin ? $otroFin->format('d/m/Y') : 'la actualidad';
throw ValidationException::withMessages([
'fecha_inicio' => "Las fechas chocan con un registro histórico existente (del {$otroInicio->format('d/m/Y')} al {$textoOtroFin}).",
]);
}
}
}
public function attachArea(Request $request, Usuario $usuario)
{
$validated = $request->validate([
'area_id' => ['required', 'exists:areas,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'responsable' => ['required', 'boolean'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$area = Area::findOrFail($validated['area_id']);
DB::transaction(function () use ($area, $usuario, $validated) {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$this->checkOverlap('area_usuario', $usuario->id, 'area_id', $area->id, $validated['fecha_inicio'], $validated['fecha_fin'] ?? null);
$usuario->areas()->attach($area->id, [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'responsable' => $validated['responsable'],
]);
});
return back()->with('success', 'Área asignada correctamente al historial.');
}
public function updateAreaPivot(Request $request, Usuario $usuario, $pivotId)
{
$validated = $request->validate([
'responsable' => ['required', 'boolean'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registro = DB::table('area_usuario')
->where('usuario_id', $usuario->id)
->where('id', $pivotId)
->firstOrFail();
if ((bool) $registro->responsable && (
! $validated['responsable']
|| Carbon::parse($registro->fecha_inicio)->toDateString() !== Carbon::parse($validated['fecha_inicio'])->toDateString()
)) {
throw ValidationException::withMessages([
'fecha_inicio' => 'Un período de responsabilidad no puede reprogramarse. Finalícelo y cree uno nuevo.',
]);
}
$area = Area::findOrFail($registro->area_id);
DB::transaction(function () use ($area, $registro, $pivotId, $validated) {
Area::query()->whereKey($area->id)->lockForUpdate()->firstOrFail();
$this->checkOverlap('area_usuario', $registro->usuario_id, 'area_id', $area->id, $validated['fecha_inicio'], $validated['fecha_fin'] ?? null, $pivotId);
DB::table('area_usuario')->where('id', $pivotId)->update([
...$validated,
'updated_at' => now(),
]);
});
return back()->with('success', 'Historial de Área actualizado.');
}
public function detachArea(Usuario $usuario, $pivotId)
{
DB::table('area_usuario')->where('usuario_id', $usuario->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de área eliminada.');
}
public function attachRol(Request $request, Usuario $usuario)
{
$validated = $request->validate([
'rol_id' => ['required', 'exists:roles,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$this->checkOverlap('rol_usuario', $usuario->id, 'rol_id', $validated['rol_id'], $validated['fecha_inicio'], $validated['fecha_fin']);
$usuario->roles()->attach($validated['rol_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
]);
return back()->with('success', 'Rol asignado correctamente al historial.');
}
public function updateRolPivot(Request $request, Usuario $usuario, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registro = DB::table('rol_usuario')
->where('usuario_id', $usuario->id)
->where('id', $pivotId)
->firstOrFail();
$this->checkOverlap('rol_usuario', $usuario->id, 'rol_id', $registro->rol_id, $validated['fecha_inicio'], $validated['fecha_fin'], $pivotId);
DB::table('rol_usuario')
->where('usuario_id', $usuario->id)
->where('id', $pivotId)
->update($validated);
return back()->with('success', 'Historial de Rol actualizado.');
}
public function detachRol(Usuario $usuario, $pivotId)
{
DB::table('rol_usuario')->where('usuario_id', $usuario->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de rol eliminada.');
}
public function attachRecurso(Request $request, Usuario $usuario)
{
$validated = $request->validate([
'recurso_id' => ['required', 'exists:recursos,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'duenio' => ['required', 'boolean'],
'activo' => ['required', 'boolean'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$this->checkOverlap('recurso_usuario', $usuario->id, 'recurso_id', $validated['recurso_id'], $validated['fecha_inicio'], $validated['fecha_fin']);
$usuario->recursos()->attach($validated['recurso_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'],
'duenio' => $validated['duenio'],
'activo' => $validated['activo'],
]);
return back()->with('success', 'Recurso asignado correctamente al historial.');
}
public function updateRecursoPivot(Request $request, Usuario $usuario, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
'duenio' => ['required', 'boolean'],
'activo' => ['required', 'boolean'],
], ['fecha_fin.after_or_equal' => 'La fecha de fin no puede ser menor a la de inicio.']);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registro = DB::table('recurso_usuario')
->where('usuario_id', $usuario->id)
->where('id', $pivotId)
->firstOrFail();
$this->checkOverlap('recurso_usuario', $usuario->id, 'recurso_id', $registro->recurso_id, $validated['fecha_inicio'], $validated['fecha_fin'], $pivotId);
DB::table('recurso_usuario')
->where('usuario_id', $usuario->id)
->where('id', $pivotId)
->update($validated);
return back()->with('success', 'Historial de Recurso actualizado.');
}
public function detachRecurso(Usuario $usuario, $pivotId)
{
DB::table('recurso_usuario')->where('usuario_id', $usuario->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de recurso eliminada.');
}
}
@@ -0,0 +1,132 @@
<?php
namespace App\Http\Controllers;
use App\Http\Requests\StoreVulnerabilidadRequest;
use App\Http\Requests\UpdateVulnerabilidadRequest;
use App\Models\TipoVulnerabilidad;
use App\Models\Vulnerabilidad;
use App\Support\RiskCalculator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Http\Request;
use Inertia\Inertia;
class VulnerabilidadController extends Controller
{
private function applyVulnerabilidadFilters(Builder $query, Request $request): Builder
{
$this->applySearch($query, $request->input('search'), ['nombre', 'descripcion', 'severidad', 'fuente']);
foreach (['nombre', 'descripcion'] as $field) {
if ($request->filled($field)) {
$query->where($field, 'like', '%'.trim((string) $request->input($field)).'%');
}
}
foreach (['severidad', 'fuente'] as $field) {
if ($request->filled($field)) {
$query->where($field, $request->input($field));
}
}
if ($request->filled('tipo_vulnerabilidad_id')) {
$tipoId = $request->input('tipo_vulnerabilidad_id');
$query->whereHas('tiposVulnerabilidades', function (Builder $query) use ($tipoId): void {
$query->where('tipos_vulnerabilidades.id', $tipoId);
});
}
return $query;
}
public function index(Request $request)
{
$filterKeys = ['search', 'nombre', 'descripcion', 'severidad', 'fuente', 'tipo_vulnerabilidad_id'];
$query = Vulnerabilidad::with('tiposVulnerabilidades');
$this->applyVulnerabilidadFilters($query, $request);
return Inertia::render('Vulnerabilidades/Index', [
'items' => $query->orderBy('id')->get(),
'filters' => $request->only($filterKeys),
'filterOptions' => [
'severidades' => $this->distinctOptions('severidad'),
'fuentes' => $this->distinctOptions('fuente'),
'tiposVulnerabilidades' => TipoVulnerabilidad::select('id as value', 'nombre as label')->orderBy('nombre')->get(),
],
]);
}
public function export(Request $request)
{
$query = Vulnerabilidad::with('tiposVulnerabilidades');
$this->applyVulnerabilidadFilters($query, $request);
return $this->streamCsv(
'vulnerabilidades_'.now()->format('Ymd_His').'.csv',
['ID', 'Nombre', 'Descripción', 'Severidad', 'Fuente', 'Tipo'],
$query->get(),
fn ($item) => [
$item->id,
$item->nombre,
$item->descripcion,
$item->severidad,
$item->fuente,
$item->tiposVulnerabilidades->pluck('nombre')->implode(', '),
],
);
}
public function create()
{
return Inertia::render('Vulnerabilidades/Create', [
'tiposVulnerabilidades' => TipoVulnerabilidad::query()->orderBy('nombre')->get(),
]);
}
public function store(StoreVulnerabilidadRequest $request)
{
$validated = $request->validated();
$tipoId = $validated['tipo_vulnerabilidad_id'];
unset($validated['tipo_vulnerabilidad_id']);
$vulnerabilidad = Vulnerabilidad::create($validated);
$vulnerabilidad->tiposVulnerabilidades()->attach($tipoId);
return redirect()->route('vulnerabilidades.index')->with('success', 'Vulnerabilidad creada exitosamente.');
}
public function edit(Vulnerabilidad $vulnerabilidad)
{
return redirect()->route('vulnerabilidades.gestionar', $vulnerabilidad);
}
public function update(UpdateVulnerabilidadRequest $request, Vulnerabilidad $vulnerabilidad)
{
$validated = $request->validated();
$tipoId = $validated['tipo_vulnerabilidad_id'];
unset($validated['tipo_vulnerabilidad_id']);
$vulnerabilidad->update($validated);
$vulnerabilidad->tiposVulnerabilidades()->sync([$tipoId]);
RiskCalculator::recalculateForVulnerabilidad($vulnerabilidad->id);
return redirect()->route('vulnerabilidades.index')->with('success', 'Vulnerabilidad actualizada.');
}
public function destroy(Vulnerabilidad $vulnerabilidad)
{
$this->deletePreservingHistory($vulnerabilidad);
return redirect()->route('vulnerabilidades.index')->with('success', 'Vulnerabilidad eliminada exitosamente.');
}
private function distinctOptions(string $field)
{
return Vulnerabilidad::query()
->select("{$field} as value", "{$field} as label")
->whereNotNull($field)
->where($field, '<>', '')
->distinct()
->orderBy($field)
->get();
}
}
@@ -0,0 +1,209 @@
<?php
namespace App\Http\Controllers;
use App\Models\Amenaza;
use App\Models\Recurso;
use App\Models\TipoVulnerabilidad;
use App\Models\Vulnerabilidad;
use App\Support\HistoricalPeriod;
use App\Support\RiskCalculator;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
class VulnerabilidadGestionController extends Controller
{
public function show(Vulnerabilidad $vulnerabilidad)
{
return Inertia::render('Vulnerabilidades/Gestionar', [
'vulnerabilidad' => $vulnerabilidad->load(['amenazas', 'recursos', 'tiposVulnerabilidades', 'riesgos.recurso', 'riesgos.amenaza']),
'amenazas' => Amenaza::orderBy('nombre')->get(),
'recursos' => Recurso::orderBy('nombre')->get(),
'tiposVulnerabilidades' => TipoVulnerabilidad::orderBy('nombre')->get(),
]);
}
public function updateField(Request $request, Vulnerabilidad $vulnerabilidad)
{
$validated = $request->validate([
'field' => ['required', Rule::in(['nombre', 'descripcion', 'severidad', 'fuente', 'tipo_vulnerabilidad_id'])],
'value' => ['nullable'],
]);
if ($validated['field'] === 'tipo_vulnerabilidad_id') {
$tipoId = validator(
['value' => $validated['value']],
['value' => ['required', 'exists:tipos_vulnerabilidades,id']],
)->validate()['value'];
$vulnerabilidad->tiposVulnerabilidades()->sync([$tipoId]);
return back()->with('success', 'Dato actualizado correctamente.');
}
$rules = [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'severidad' => ['nullable', 'string', 'in:Baja,Media,Alta,Crítica'],
'fuente' => ['nullable', 'string', Rule::in(['Interna', 'Externa', 'Ambas'])],
];
$value = validator(
['value' => $validated['value']],
['value' => $rules[$validated['field']]],
)->validate()['value'] ?? null;
$vulnerabilidad->update([$validated['field'] => $value]);
if ($validated['field'] === 'severidad') {
RiskCalculator::recalculateForVulnerabilidad($vulnerabilidad->id);
}
return back()->with('success', 'Dato actualizado correctamente.');
}
public function attachAmenaza(Request $request, Vulnerabilidad $vulnerabilidad)
{
$validated = $request->validate([
'amenaza_id' => ['required', 'exists:amenazas,id'],
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('amenazas_vulnerabilidades')->where('vulnerabilidades_id', $vulnerabilidad->id)->where('amenazas_id', $validated['amenaza_id'])->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null ? true : $inicio->lte($otroFin)) && ($fin === null ? true : $fin->gte($otroInicio))) {
throw \Illuminate\Validation\ValidationException::withMessages(['fecha_inicio' => 'Las fechas chocan con un registro existente.']);
}
}
$vulnerabilidad->amenazas()->attach($validated['amenaza_id'], [
'fecha_inicio' => $validated['fecha_inicio'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Amenaza asociada correctamente.');
}
public function detachAmenaza(Vulnerabilidad $vulnerabilidad, $pivotId)
{
DB::table('amenazas_vulnerabilidades')->where('vulnerabilidades_id', $vulnerabilidad->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de amenaza eliminada correctamente.');
}
public function updateAmenazaPivot(Request $request, Vulnerabilidad $vulnerabilidad, $pivotId)
{
$validated = $request->validate([
'fecha_inicio' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_inicio'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('amenazas_vulnerabilidades')
->where('vulnerabilidades_id', $vulnerabilidad->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_inicio']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('amenazas_vulnerabilidades')->where('vulnerabilidades_id', $vulnerabilidad->id)->where('amenazas_id', $registroActual->amenazas_id)->where('id', '!=', $pivotId)->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_inicio);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null ? true : $inicio->lte($otroFin)) && ($fin === null ? true : $fin->gte($otroInicio))) {
throw \Illuminate\Validation\ValidationException::withMessages(['fecha_inicio' => 'Las fechas chocan con un registro existente.']);
}
}
DB::table('amenazas_vulnerabilidades')
->where('vulnerabilidades_id', $vulnerabilidad->id)
->where('id', $pivotId)
->update(['fecha_inicio' => $validated['fecha_inicio'], 'fecha_fin' => $validated['fecha_fin'], 'updated_at' => now()]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
public function attachRecurso(Request $request, Vulnerabilidad $vulnerabilidad)
{
$validated = $request->validate([
'recurso_id' => ['required', 'exists:recursos,id'],
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$inicio = Carbon::parse($validated['fecha_identificacion']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recursos_vulnerabilidad')->where('vulnerabilidad_id', $vulnerabilidad->id)->where('recursos_id', $validated['recurso_id'])->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_identificacion);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null ? true : $inicio->lte($otroFin)) && ($fin === null ? true : $fin->gte($otroInicio))) {
throw \Illuminate\Validation\ValidationException::withMessages(['fecha_inicio' => 'Las fechas chocan con un registro existente.']);
}
}
$vulnerabilidad->recursos()->attach($validated['recurso_id'], [
'fecha_identificacion' => $validated['fecha_identificacion'],
'fecha_fin' => $validated['fecha_fin'] ?? null,
'created_at' => now(),
'updated_at' => now(),
]);
return back()->with('success', 'Recurso asociado correctamente.');
}
public function detachRecurso(Vulnerabilidad $vulnerabilidad, $pivotId)
{
DB::table('recursos_vulnerabilidad')->where('vulnerabilidad_id', $vulnerabilidad->id)->where('id', $pivotId)->delete();
return back()->with('success', 'Asignación de recurso eliminada correctamente.');
}
public function updateRecursoPivot(Request $request, Vulnerabilidad $vulnerabilidad, $pivotId)
{
$validated = $request->validate([
'fecha_identificacion' => ['required', 'date'],
'fecha_fin' => ['nullable', 'date', 'after_or_equal:fecha_identificacion'],
]);
$validated['fecha_fin'] = HistoricalPeriod::inclusiveEnd($validated['fecha_fin'] ?? null);
$registroActual = DB::table('recursos_vulnerabilidad')
->where('vulnerabilidad_id', $vulnerabilidad->id)
->where('id', $pivotId)
->firstOrFail();
$inicio = Carbon::parse($validated['fecha_identificacion']);
$fin = $validated['fecha_fin'] ? Carbon::parse($validated['fecha_fin']) : null;
$otrosRegistros = DB::table('recursos_vulnerabilidad')->where('vulnerabilidad_id', $vulnerabilidad->id)->where('recursos_id', $registroActual->recursos_id)->where('id', '!=', $pivotId)->get();
foreach ($otrosRegistros as $otro) {
$otroInicio = Carbon::parse($otro->fecha_identificacion);
$otroFin = $otro->fecha_fin ? Carbon::parse($otro->fecha_fin) : null;
if (($otroFin === null ? true : $inicio->lte($otroFin)) && ($fin === null ? true : $fin->gte($otroInicio))) {
throw \Illuminate\Validation\ValidationException::withMessages(['fecha_inicio' => 'Las fechas chocan con un registro existente.']);
}
}
DB::table('recursos_vulnerabilidad')
->where('vulnerabilidad_id', $vulnerabilidad->id)
->where('id', $pivotId)
->update(['fecha_identificacion' => $validated['fecha_identificacion'], 'fecha_fin' => $validated['fecha_fin'], 'updated_at' => now()]);
return back()->with('success', 'Asignación actualizada correctamente.');
}
}
@@ -0,0 +1,65 @@
<?php
namespace App\Http\Middleware;
use App\Models\Notificacion;
use App\Services\NotificacionService;
use Illuminate\Http\Request;
use Inertia\Middleware;
class HandleInertiaRequests extends Middleware
{
/**
* The root template that is loaded on the first page visit.
*
* @var string
*/
protected $rootView = 'app';
/**
* Determine the current asset version.
*/
public function version(Request $request): ?string
{
return parent::version($request);
}
/**
* Define the props that are shared by default.
*
* @return array<string, mixed>
*/
public function share(Request $request): array
{
$user = $request->user();
return [
...parent::share($request),
'auth' => [
'user' => $user ? $user->only(['id', 'name', 'email']) : null,
'roles' => fn () => $user?->getRoleNames() ?? [],
],
'flash' => [
'success' => fn () => $request->session()->get('success'),
'error' => fn () => $request->session()->get('error'),
],
'notifications' => function () use ($request) {
$user = $request->user();
if (! $user) {
return ['count' => 0, 'recientes' => []];
}
app(NotificacionService::class)->generarNotificacionesPendientes();
return [
'count' => Notificacion::where('user_id', $user->id)->where('leido', false)->count(),
'recientes' => Notificacion::where('user_id', $user->id)
->where('leido', false)
->latest()
->take(5)
->get(['id', 'titulo', 'mensaje', 'created_at']),
];
},
];
}
}
+85
View File
@@ -0,0 +1,85 @@
<?php
namespace App\Http\Requests\Auth;
use Illuminate\Auth\Events\Lockout;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
class LoginRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'email' => ['required', 'string', 'email'],
'password' => ['required', 'string'],
];
}
/**
* Attempt to authenticate the request's credentials.
*
* @throws \Illuminate\Validation\ValidationException
*/
public function authenticate(): void
{
$this->ensureIsNotRateLimited();
if (! Auth::attempt($this->only('email', 'password'), $this->boolean('remember'))) {
RateLimiter::hit($this->throttleKey());
throw ValidationException::withMessages([
'email' => trans('auth.failed'),
]);
}
RateLimiter::clear($this->throttleKey());
}
/**
* Ensure the login request is not rate limited.
*
* @throws \Illuminate\Validation\ValidationException
*/
public function ensureIsNotRateLimited(): void
{
if (! RateLimiter::tooManyAttempts($this->throttleKey(), 5)) {
return;
}
event(new Lockout($this));
$seconds = RateLimiter::availableIn($this->throttleKey());
throw ValidationException::withMessages([
'email' => trans('auth.throttle', [
'seconds' => $seconds,
'minutes' => ceil($seconds / 60),
]),
]);
}
/**
* Get the rate limiting throttle key for the request.
*/
public function throttleKey(): string
{
return Str::transliterate(Str::lower($this->string('email')).'|'.$this->ip());
}
}
@@ -0,0 +1,30 @@
<?php
namespace App\Http\Requests;
use App\Models\User;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class ProfileUpdateRequest extends FormRequest
{
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'name' => ['required', 'string', 'max:255'],
'email' => [
'required',
'string',
'lowercase',
'email',
'max:255',
Rule::unique(User::class)->ignore($this->user()->id),
],
];
}
}
+26
View File
@@ -0,0 +1,26 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreRiesgoRequest extends FormRequest
{
public function authorize(): bool
{
return true;
}
public function rules(): array
{
return [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'fecha_alta' => ['required', 'date'],
'fecha_baja' => ['nullable', 'date', 'after_or_equal:fecha_alta'],
'recursos_id' => ['required', 'integer', 'exists:recursos,id'],
'amenazas_id' => ['required', 'integer', 'exists:amenazas,id'],
'vulnerabilidades_id' => ['required', 'integer', 'exists:vulnerabilidades,id'],
];
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class StoreVulnerabilidadRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
public function rules(): array
{
return [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'severidad' => ['nullable', 'string', 'in:Baja,Media,Alta,Crítica'],
'fuente' => ['nullable', 'string', Rule::in(['Interna', 'Externa', 'Ambas'])],
'tipo_vulnerabilidad_id' => ['required', 'exists:tipos_vulnerabilidades,id'],
];
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class UpdateVulnerabilidadRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
public function rules(): array
{
return [
'nombre' => ['required', 'string', 'max:35'],
'descripcion' => ['nullable', 'string', 'max:185'],
'severidad' => ['nullable', 'string', Rule::in(['Baja', 'Media', 'Alta', 'Crítica'])],
'fuente' => ['nullable', 'string', Rule::in(['Interna', 'Externa', 'Ambas'])],
'tipo_vulnerabilidad_id' => ['required', 'exists:tipos_vulnerabilidades,id'],
];
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Http\Resources;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;
class VulnerabilidadResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @return array<string, mixed>
*/
public function toArray(Request $request): array
{
return [
'id' => $this->id,
'nombre' => $this->nombre,
'descripcion' => $this->descripcion,
'criticidad' => $this->criticidad,
'fecha_identificacion' => $this->fecha_identificacion,
'fecha_cierre' => $this->fecha_cierre,
'created_at' => $this->created_at?->toDateTimeString(),
'updated_at' => $this->updated_at?->toDateTimeString(),
];
}
}
+38
View File
@@ -0,0 +1,38 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Amenaza extends Model
{
use LogsAuditoria;
protected $table = 'amenazas';
protected $fillable = ['nombre', 'descripcion', 'nivel_de_amenaza', 'fuente', 'origen', 'fecha_alta', 'fecha_baja'];
protected $casts = [
'fecha_alta' => 'datetime',
'fecha_baja' => 'datetime',
];
public function tiposAmenazas()
{
return $this->belongsToMany(TipoAmenaza::class, 'amenaza_tipos_amenaza', 'amenaza_id', 'tipo_amenaza_id')
->withTimestamps();
}
public function vulnerabilidades()
{
return $this->belongsToMany(Vulnerabilidad::class, 'amenazas_vulnerabilidades', 'amenazas_id', 'vulnerabilidades_id')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function riesgos()
{
return $this->hasMany(Riesgo::class, 'amenazas_id');
}
}
+63
View File
@@ -0,0 +1,63 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
class Area extends Model
{
use LogsAuditoria;
protected $table = 'areas';
protected $fillable = [
'nombre', 'descripcion', 'correo', 'activo', 'fecha_alta', 'fecha_baja',
'direccion', 'telefono', 'motivo_alta',
];
protected $appends = ['responsable'];
protected $casts = [
'activo' => 'boolean',
'fecha_alta' => 'datetime',
'fecha_baja' => 'datetime',
];
public function usuarios()
{
return $this->belongsToMany(Usuario::class, 'area_usuario')
->withPivot(['id', 'fecha_inicio', 'fecha_fin', 'responsable'])
->withTimestamps();
}
public function recursos()
{
return $this->belongsToMany(Recurso::class, 'area_recurso')
->withPivot(['id', 'fecha_inicio', 'fecha_fin'])
->withTimestamps();
}
public function getResponsableAttribute(): ?string
{
$usuario = $this->responsableActualUsuario();
return $usuario ? trim("{$usuario->nombre} {$usuario->apellido}") : null;
}
public function responsableActualUsuario(): ?Usuario
{
$ahora = now();
$usuarios = $this->relationLoaded('usuarios')
? $this->getRelation('usuarios')
: $this->usuarios()->get();
return $usuarios
->filter(fn (Usuario $usuario): bool => (bool) $usuario->pivot->responsable
&& (! $usuario->pivot->fecha_inicio || Carbon::parse($usuario->pivot->fecha_inicio)->lte($ahora))
&& (! $usuario->pivot->fecha_fin || Carbon::parse($usuario->pivot->fecha_fin)->gt($ahora)))
->sortByDesc(fn (Usuario $usuario) => $usuario->pivot->fecha_inicio)
->first();
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Auditoria extends Model
{
protected $table = 'auditorias';
protected $fillable = ['user_id', 'accion', 'tabla', 'campo_id', 'valor_anterior', 'valor_nuevo', 'ip'];
public function getCreatedAtAttribute($value)
{
return \Carbon\Carbon::parse($value)->format('d/m/Y H:i:s');
}
public function user()
{
return $this->belongsTo(User::class);
}
}
+55
View File
@@ -0,0 +1,55 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
class Backup extends Model
{
protected $fillable = [
'filename',
'original_size',
'compressed_size',
'status',
'frequency',
'created_by',
'started_at',
'completed_at',
'error_message',
];
protected $casts = [
'original_size' => 'integer',
'compressed_size' => 'integer',
'started_at' => 'datetime',
'completed_at' => 'datetime',
];
public function user(): BelongsTo
{
return $this->belongsTo(User::class, 'created_by');
}
public function getFormattedSizeAttribute(): string
{
return $this->formatBytes($this->compressed_size);
}
public function getFormattedOriginalSizeAttribute(): string
{
return $this->formatBytes($this->original_size);
}
private function formatBytes(int $bytes): string
{
if ($bytes === 0) {
return '0 B';
}
$units = ['B', 'KB', 'MB', 'GB'];
$i = (int) floor(log($bytes, 1024));
$i = min($i, count($units) - 1);
return round($bytes / (1024 ** $i), 2).' '.$units[$i];
}
}
+34
View File
@@ -0,0 +1,34 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Control extends Model
{
use LogsAuditoria;
protected $table = 'controles';
protected $fillable = ['nombre', 'descripcion', 'estado', 'nivel_de_control', 'fecha_inicio', 'fecha_fin'];
protected $casts = [
'fecha_inicio' => 'datetime',
'fecha_fin' => 'datetime',
];
public function tiposControles()
{
return $this->belongsToMany(TipoControl::class, 'control_tipos_control', 'control_id', 'tipo_control_id')
->withPivot(['fecha_inicio', 'fecha_fin'])
->withTimestamps();
}
public function riesgos()
{
return $this->belongsToMany(Riesgo::class, 'riesgo_control', 'control_id', 'riesgo_id')
->withPivot(['id', 'fecha_identificacion', 'fecha_fin'])
->withTimestamps();
}
}
+17
View File
@@ -0,0 +1,17 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Notificacion extends Model
{
protected $fillable = ['user_id', 'titulo', 'mensaje', 'leido'];
protected $table = 'notificaciones';
public function user()
{
return $this->belongsTo(User::class);
}
}
+44
View File
@@ -0,0 +1,44 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Perfil extends Model
{
use LogsAuditoria;
protected $table = 'perfiles';
protected $fillable = ['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin'];
protected $casts = [
'fecha_inicio' => 'datetime',
'fecha_fin' => 'datetime',
];
public function roles()
{
return $this->belongsToMany(Rol::class, 'perfil_rol')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function permisos()
{
return $this->belongsToMany(Permiso::class, 'permiso_perfil')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function recursos()
{
return $this->belongsToMany(Recurso::class, 'perfil_recurso')
->withPivot([
'id', 'evidencia', 'fecha_inicio', 'fecha_fin',
'fecha_revision', 'fecha_proxima_revision',
])
->withTimestamps();
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Permiso extends Model
{
use LogsAuditoria;
protected $table = 'permisos';
protected $fillable = ['nombre', 'accion', 'justificacion', 'estado'];
public function perfiles()
{
return $this->belongsToMany(Perfil::class, 'permiso_perfil')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
}
+75
View File
@@ -0,0 +1,75 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Recurso extends Model
{
use LogsAuditoria;
protected $table = 'recursos';
protected $fillable = ['nombre', 'descripcion', 'tipo_recurso_id', 'impacto', 'fecha_alta', 'fecha_baja'];
protected $casts = [
'fecha_alta' => 'datetime',
'fecha_baja' => 'datetime',
];
public function tipoRecurso()
{
return $this->belongsTo(TipoRecurso::class);
}
public function usuarios()
{
return $this->belongsToMany(Usuario::class, 'recurso_usuario')
->withPivot('id', 'fecha_inicio', 'fecha_fin', 'duenio', 'activo')
->withTimestamps();
}
public function responsables()
{
return $this->belongsToMany(Usuario::class, 'recurso_usuario')
->withPivot(['fecha_inicio', 'fecha_fin', 'activo', 'duenio'])
->wherePivot('activo', 1)
->wherePivot('duenio', 1)
->wherePivot('fecha_inicio', '<=', now())
->where(function ($query): void {
$query->whereNull('recurso_usuario.fecha_fin')
->orWhere('recurso_usuario.fecha_fin', '>', now());
})
->withTimestamps();
}
public function areas()
{
return $this->belongsToMany(Area::class, 'area_recurso')
->withPivot(['id', 'fecha_inicio', 'fecha_fin'])
->withTimestamps();
}
public function perfiles()
{
return $this->belongsToMany(Perfil::class, 'perfil_recurso')
->withPivot([
'id', 'evidencia', 'fecha_inicio', 'fecha_fin',
'fecha_revision', 'fecha_proxima_revision',
])
->withTimestamps();
}
public function vulnerabilidades()
{
return $this->belongsToMany(Vulnerabilidad::class, 'recursos_vulnerabilidad', 'recursos_id', 'vulnerabilidad_id')
->withPivot(['id', 'fecha_identificacion', 'fecha_fin'])
->withTimestamps();
}
public function riesgos()
{
return $this->hasMany(Riesgo::class, 'recursos_id');
}
}
+52
View File
@@ -0,0 +1,52 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Riesgo extends Model
{
use LogsAuditoria;
public const NIVELES = ['Bajo', 'Medio', 'Alto', 'Crítico'];
protected $table = 'riesgos';
protected $fillable = [
'nombre', 'descripcion', 'riesgo_inherente', 'riesgo_residual',
'probabilidad_inherente', 'probabilidad_residual',
'puntaje_inherente', 'puntaje_residual',
'total_efect',
'calculado_en',
'fecha_alta', 'fecha_baja', 'recursos_id', 'amenazas_id', 'vulnerabilidades_id',
];
protected $casts = [
'fecha_alta' => 'datetime',
'fecha_baja' => 'datetime',
'calculado_en' => 'datetime',
];
public function recurso()
{
return $this->belongsTo(Recurso::class, 'recursos_id');
}
public function amenaza()
{
return $this->belongsTo(Amenaza::class, 'amenazas_id');
}
public function vulnerabilidad()
{
return $this->belongsTo(Vulnerabilidad::class, 'vulnerabilidades_id');
}
public function controles()
{
return $this->belongsToMany(Control::class, 'riesgo_control', 'riesgo_id', 'control_id')
->withPivot(['id', 'fecha_identificacion', 'fecha_fin'])
->withTimestamps();
}
}
+34
View File
@@ -0,0 +1,34 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Rol extends Model
{
use LogsAuditoria;
protected $table = 'roles';
protected $fillable = ['nombre', 'descripcion', 'fecha_inicio', 'fecha_fin'];
protected $casts = [
'fecha_inicio' => 'datetime',
'fecha_fin' => 'datetime',
];
public function usuarios()
{
return $this->belongsToMany(Usuario::class, 'rol_usuario')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function perfiles()
{
return $this->belongsToMany(Perfil::class, 'perfil_rol')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
}
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class TipoAmenaza extends Model
{
use LogsAuditoria;
protected $table = 'tipos_amenazas';
protected $fillable = ['nombre', 'descripcion'];
public function amenazas()
{
return $this->belongsToMany(Amenaza::class, 'amenaza_tipos_amenaza', 'tipo_amenaza_id', 'amenaza_id')
->withTimestamps();
}
}
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class TipoControl extends Model
{
use LogsAuditoria;
protected $table = 'tipos_controles';
protected $fillable = ['nombre', 'descripcion'];
public function controles()
{
return $this->belongsToMany(Control::class, 'control_tipos_control', 'tipo_control_id', 'control_id')
->withPivot(['fecha_inicio', 'fecha_fin'])
->withTimestamps();
}
}
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class TipoRecurso extends Model
{
use LogsAuditoria;
protected $table = 'tipos_recursos';
protected $fillable = ['nombre', 'descripcion'];
public function recursos()
{
return $this->hasMany(Recurso::class);
}
}
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class TipoUsuario extends Model
{
use LogsAuditoria;
protected $table = 'tipos_usuarios';
protected $fillable = ['nombre', 'descripcion'];
public function usuarios()
{
return $this->hasMany(Usuario::class);
}
}
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class TipoVulnerabilidad extends Model
{
use LogsAuditoria;
protected $table = 'tipos_vulnerabilidades';
protected $fillable = ['nombre', 'descripcion'];
public function vulnerabilidades()
{
return $this->belongsToMany(Vulnerabilidad::class, 'vulnerabilidades_tipos_vulnerabilidades', 'tipos_vulnerabilidades_id', 'vulnerabilidades_id')
->withTimestamps();
}
}
+57
View File
@@ -0,0 +1,57 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Spatie\Permission\Traits\HasRoles;
class User extends Authenticatable
{
use HasFactory, HasRoles, Notifiable;
/**
* The attributes that are mass assignable.
*
* @var list<string>
*/
protected $fillable = [
'name',
'email',
'password',
];
/**
* The attributes that should be hidden for serialization.
*
* @var list<string>
*/
protected $hidden = [
'password',
'remember_token',
];
/**
* Get the attributes that should be cast.
*
* @return array<string, string>
*/
protected function casts(): array
{
return [
'email_verified_at' => 'datetime',
'password' => 'hashed',
];
}
public function auditorias()
{
return $this->hasMany(Auditoria::class);
}
public function notificaciones()
{
return $this->hasMany(Notificacion::class);
}
}
+69
View File
@@ -0,0 +1,69 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\DB;
class Usuario extends Model
{
use LogsAuditoria;
protected $table = 'usuarios';
protected $fillable = [
'nombre',
'apellido',
'correo',
'documento',
'telefono',
'activo',
'tipo_usuario_id',
'fecha_alta',
'fecha_baja',
];
protected $casts = [
'activo' => 'boolean',
'fecha_alta' => 'datetime',
'fecha_baja' => 'datetime',
];
public function tipoUsuario()
{
return $this->belongsTo(TipoUsuario::class);
}
public function areas()
{
return $this->belongsToMany(Area::class, 'area_usuario')
->withPivot('id', 'fecha_inicio', 'fecha_fin', 'responsable')
->withTimestamps();
}
public function roles()
{
return $this->belongsToMany(Rol::class, 'rol_usuario')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function recursos()
{
return $this->belongsToMany(Recurso::class, 'recurso_usuario')
->withPivot('id', 'fecha_inicio', 'fecha_fin', 'duenio', 'activo')
->withTimestamps();
}
public static function buscar($filtros)
{
return DB::table('usuarios as u')
->select('u.*')
->when($filtros->documento, fn ($query, $documento) => $query->where('u.documento', $documento))
->when($filtros->apellido, fn ($query, $apellido) => $query->where('u.apellido', 'LIKE', "%{$apellido}%"))
->when($filtros->nombre, fn ($query, $nombre) => $query->where('u.nombre', 'LIKE', "%{$nombre}%"))
->limit(25)
->get();
}
}
+40
View File
@@ -0,0 +1,40 @@
<?php
namespace App\Models;
use App\Traits\LogsAuditoria;
use Illuminate\Database\Eloquent\Model;
class Vulnerabilidad extends Model
{
use LogsAuditoria;
protected $table = 'vulnerabilidades';
protected $fillable = ['nombre', 'descripcion', 'severidad', 'fuente'];
public function amenazas()
{
return $this->belongsToMany(Amenaza::class, 'amenazas_vulnerabilidades', 'vulnerabilidades_id', 'amenazas_id')
->withPivot('id', 'fecha_inicio', 'fecha_fin')
->withTimestamps();
}
public function recursos()
{
return $this->belongsToMany(Recurso::class, 'recursos_vulnerabilidad', 'vulnerabilidad_id', 'recursos_id')
->withPivot('id', 'fecha_identificacion', 'fecha_fin')
->withTimestamps();
}
public function tiposVulnerabilidades()
{
return $this->belongsToMany(TipoVulnerabilidad::class, 'vulnerabilidades_tipos_vulnerabilidades', 'vulnerabilidades_id', 'tipos_vulnerabilidades_id')
->withTimestamps();
}
public function riesgos()
{
return $this->hasMany(Riesgo::class, 'vulnerabilidades_id');
}
}
+49
View File
@@ -0,0 +1,49 @@
<?php
namespace App\Providers;
use App\Models\Auditoria;
use Illuminate\Auth\Events\Login;
use Illuminate\Auth\Events\Logout;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Vite;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Register any application services.
*/
public function register(): void
{
//
}
/**
* Bootstrap any application services.
*/
public function boot(): void
{
Vite::prefetch(concurrency: 3);
Event::listen(Login::class, function ($event) {
Auditoria::create([
'user_id' => $event->user->id,
'accion' => 'login',
'tabla' => 'users',
'campo_id' => $event->user->id,
'ip' => request()->ip(),
]);
});
Event::listen(Logout::class, function ($event) {
Auditoria::create([
'user_id' => $event->user->id,
'accion' => 'logout',
'tabla' => 'users',
'campo_id' => $event->user->id,
'ip' => request()->ip(),
]);
});
}
}
+313
View File
@@ -0,0 +1,313 @@
<?php
namespace App\Services;
use App\Models\Notificacion;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
class NotificacionService
{
private function getUserIds(): array
{
return DB::table('users')
->join('usuarios', 'users.email', '=', 'usuarios.correo')
->pluck('users.id', 'usuarios.id')
->toArray();
}
private function getAdminUserIds(): array
{
return DB::table('users')
->join('auth_model_has_roles', 'auth_model_has_roles.model_id', '=', 'users.id')
->join('auth_roles', 'auth_roles.id', '=', 'auth_model_has_roles.role_id')
->where('auth_roles.name', 'administrador')
->where('auth_model_has_roles.model_type', '=', 'App\\Models\\User')
->pluck('users.id')
->toArray();
}
private function alreadyNotified(int $userId, string $titulo, int $days = 7): bool
{
return Notificacion::where('user_id', $userId)
->where('titulo', $titulo)
->where('created_at', '>=', Carbon::now()->subDays($days))
->exists();
}
private function createIfUnique(int $userId, string $titulo, string $mensaje): void
{
if (! $this->alreadyNotified($userId, $titulo)) {
Notificacion::create([
'user_id' => $userId,
'titulo' => $titulo,
'mensaje' => $mensaje,
'leido' => false,
]);
}
}
private function notifyAdmin(int $adminId, string $titulo, string $mensaje): void
{
$this->createIfUnique($adminId, $titulo, $mensaje);
}
public function generarNotificacionesPendientes(): void
{
$userMap = $this->getUserIds();
$adminIds = $this->getAdminUserIds();
if (empty($userMap) && empty($adminIds)) {
return;
}
$hoy = Carbon::now();
$limite = Carbon::now()->addDays(7);
$permisosPorVencer = DB::table('permiso_perfil')
->join('permisos', 'permiso_perfil.permiso_id', '=', 'permisos.id')
->join('perfiles', 'permiso_perfil.perfil_id', '=', 'perfiles.id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'permiso_perfil.perfil_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'perfil_rol.rol_id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '<=', $limite)
->where('permiso_perfil.fecha_fin', '>=', $hoy)
->select('rol_usuario.usuario_id', 'permisos.nombre as permiso_nombre', 'perfiles.nombre as perfil_nombre', 'permiso_perfil.fecha_fin')
->distinct()
->get();
foreach ($permisosPorVencer as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$dias = abs(abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy)));
$this->createIfUnique(
$uid,
'Permiso por vencer',
"El permiso \"{$row->permiso_nombre}\" del perfil \"{$row->perfil_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
foreach ($adminIds as $adminId) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->notifyAdmin(
$adminId,
"Permiso por vencer - {$row->perfil_nombre}",
"El permiso \"{$row->permiso_nombre}\" del perfil \"{$row->perfil_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
}
$permisosVencidos = DB::table('permiso_perfil')
->join('permisos', 'permiso_perfil.permiso_id', '=', 'permisos.id')
->join('perfiles', 'permiso_perfil.perfil_id', '=', 'perfiles.id')
->join('perfil_rol', 'perfil_rol.perfil_id', '=', 'permiso_perfil.perfil_id')
->join('rol_usuario', 'rol_usuario.rol_id', '=', 'perfil_rol.rol_id')
->join('usuarios', 'usuarios.id', '=', 'rol_usuario.usuario_id')
->whereNotNull('permiso_perfil.fecha_fin')
->where('permiso_perfil.fecha_fin', '<', $hoy)
->select('rol_usuario.usuario_id', 'permisos.nombre as permiso_nombre', 'perfiles.nombre as perfil_nombre', 'permiso_perfil.fecha_fin')
->distinct()
->get();
foreach ($permisosVencidos as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$this->createIfUnique(
$uid,
'Permiso vencido',
"El permiso \"{$row->permiso_nombre}\" del perfil \"{$row->perfil_nombre}\" venció el {$row->fecha_fin}."
);
}
foreach ($adminIds as $adminId) {
$this->notifyAdmin(
$adminId,
"Permiso vencido - {$row->perfil_nombre}",
"El permiso \"{$row->permiso_nombre}\" del perfil \"{$row->perfil_nombre}\" venció el {$row->fecha_fin}."
);
}
}
$asignacionesPorVencer = DB::table('recurso_usuario')
->join('usuarios', 'recurso_usuario.usuario_id', '=', 'usuarios.id')
->join('recursos', 'recurso_usuario.recurso_id', '=', 'recursos.id')
->whereNotNull('recurso_usuario.fecha_fin')
->where('recurso_usuario.fecha_fin', '<=', $limite)
->where('recurso_usuario.fecha_fin', '>=', $hoy)
->select('recurso_usuario.usuario_id', 'usuarios.nombre as usuario_nombre', 'recursos.nombre as recurso_nombre', 'recurso_usuario.fecha_fin')
->get();
foreach ($asignacionesPorVencer as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->createIfUnique(
$uid,
'Asignación a recurso por vencer',
"La asignación de \"{$row->usuario_nombre}\" al recurso \"{$row->recurso_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
foreach ($adminIds as $adminId) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->notifyAdmin(
$adminId,
"Asignación a recurso por vencer - {$row->usuario_nombre}",
"La asignación de \"{$row->usuario_nombre}\" al recurso \"{$row->recurso_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
}
$asignacionesVencidas = DB::table('recurso_usuario')
->join('usuarios', 'recurso_usuario.usuario_id', '=', 'usuarios.id')
->join('recursos', 'recurso_usuario.recurso_id', '=', 'recursos.id')
->whereNotNull('recurso_usuario.fecha_fin')
->where('recurso_usuario.fecha_fin', '<', $hoy)
->select('recurso_usuario.usuario_id', 'usuarios.nombre as usuario_nombre', 'recursos.nombre as recurso_nombre', 'recurso_usuario.fecha_fin')
->get();
foreach ($asignacionesVencidas as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$this->createIfUnique(
$uid,
'Asignación a recurso vencida',
"La asignación de \"{$row->usuario_nombre}\" al recurso \"{$row->recurso_nombre}\" venció el {$row->fecha_fin}."
);
}
foreach ($adminIds as $adminId) {
$this->notifyAdmin(
$adminId,
"Asignación a recurso vencida - {$row->usuario_nombre}",
"La asignación de \"{$row->usuario_nombre}\" al recurso \"{$row->recurso_nombre}\" venció el {$row->fecha_fin}."
);
}
}
$areasPorVencer = DB::table('area_usuario')
->join('usuarios', 'area_usuario.usuario_id', '=', 'usuarios.id')
->join('areas', 'area_usuario.area_id', '=', 'areas.id')
->whereNotNull('area_usuario.fecha_fin')
->where('area_usuario.fecha_fin', '<=', $limite)
->where('area_usuario.fecha_fin', '>=', $hoy)
->select('area_usuario.usuario_id', 'usuarios.nombre as usuario_nombre', 'areas.nombre as area_nombre', 'area_usuario.fecha_fin')
->get();
foreach ($areasPorVencer as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->createIfUnique(
$uid,
'Asignación a área por vencer',
"La asignación de \"{$row->usuario_nombre}\" al área \"{$row->area_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
foreach ($adminIds as $adminId) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->notifyAdmin(
$adminId,
"Asignación a área por vencer - {$row->usuario_nombre}",
"La asignación de \"{$row->usuario_nombre}\" al área \"{$row->area_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
}
$areasVencidas = DB::table('area_usuario')
->join('usuarios', 'area_usuario.usuario_id', '=', 'usuarios.id')
->join('areas', 'area_usuario.area_id', '=', 'areas.id')
->whereNotNull('area_usuario.fecha_fin')
->where('area_usuario.fecha_fin', '<', $hoy)
->select('area_usuario.usuario_id', 'usuarios.nombre as usuario_nombre', 'areas.nombre as area_nombre', 'area_usuario.fecha_fin')
->get();
foreach ($areasVencidas as $row) {
$uid = $userMap[$row->usuario_id ?? null] ?? null;
if ($uid !== null) {
$this->createIfUnique(
$uid,
'Asignación a área vencida',
"La asignación de \"{$row->usuario_nombre}\" al área \"{$row->area_nombre}\" venció el {$row->fecha_fin}."
);
}
foreach ($adminIds as $adminId) {
$this->notifyAdmin(
$adminId,
"Asignación a área vencida - {$row->usuario_nombre}",
"La asignación de \"{$row->usuario_nombre}\" al área \"{$row->area_nombre}\" venció el {$row->fecha_fin}."
);
}
}
$perfilRecursoPorVencer = DB::table('perfil_recurso')
->join('perfiles', 'perfil_recurso.perfil_id', '=', 'perfiles.id')
->join('recursos', 'perfil_recurso.recurso_id', '=', 'recursos.id')
->whereNotNull('perfil_recurso.fecha_fin')
->where('perfil_recurso.fecha_fin', '<=', $limite)
->where('perfil_recurso.fecha_fin', '>=', $hoy)
->select('perfil_recurso.perfil_id', 'perfiles.nombre as perfil_nombre', 'recursos.nombre as recurso_nombre', 'perfil_recurso.fecha_fin')
->get();
foreach ($perfilRecursoPorVencer as $row) {
$usuariosEnPerfil = DB::table('rol_usuario')
->join('perfil_rol', 'rol_usuario.rol_id', '=', 'perfil_rol.rol_id')
->where('perfil_rol.perfil_id', $row->perfil_id)
->pluck('rol_usuario.usuario_id')
->toArray();
foreach ($usuariosEnPerfil as $usuarioId) {
$uid = $userMap[$usuarioId] ?? null;
if ($uid !== null) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->createIfUnique(
$uid,
'Perfil de recurso por vencer',
"El perfil \"{$row->perfil_nombre}\" asignado al recurso \"{$row->recurso_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
}
foreach ($adminIds as $adminId) {
$dias = abs(Carbon::parse($row->fecha_fin)->diffInDays($hoy));
$this->notifyAdmin(
$adminId,
"Perfil de recurso por vencer - {$row->perfil_nombre}",
"El perfil \"{$row->perfil_nombre}\" asignado al recurso \"{$row->recurso_nombre}\" vence en {$dias} día(s) ({$row->fecha_fin})."
);
}
}
$perfilRecursoVencidos = DB::table('perfil_recurso')
->join('perfiles', 'perfil_recurso.perfil_id', '=', 'perfiles.id')
->join('recursos', 'perfil_recurso.recurso_id', '=', 'recursos.id')
->whereNotNull('perfil_recurso.fecha_fin')
->where('perfil_recurso.fecha_fin', '<', $hoy)
->select('perfil_recurso.perfil_id', 'perfiles.nombre as perfil_nombre', 'recursos.nombre as recurso_nombre', 'perfil_recurso.fecha_fin')
->get();
foreach ($perfilRecursoVencidos as $row) {
$usuariosEnPerfil = DB::table('rol_usuario')
->join('perfil_rol', 'rol_usuario.rol_id', '=', 'perfil_rol.rol_id')
->where('perfil_rol.perfil_id', $row->perfil_id)
->pluck('rol_usuario.usuario_id')
->toArray();
foreach ($usuariosEnPerfil as $usuarioId) {
$uid = $userMap[$usuarioId] ?? null;
if ($uid !== null) {
$this->createIfUnique(
$uid,
'Perfil de recurso vencido',
"El perfil \"{$row->perfil_nombre}\" asignado al recurso \"{$row->recurso_nombre}\" venció el {$row->fecha_fin}."
);
}
}
foreach ($adminIds as $adminId) {
$this->notifyAdmin(
$adminId,
"Perfil de recurso vencido - {$row->perfil_nombre}",
"El perfil \"{$row->perfil_nombre}\" asignado al recurso \"{$row->recurso_nombre}\" venció el {$row->fecha_fin}."
);
}
}
}
}
+128
View File
@@ -0,0 +1,128 @@
<?php
namespace App\Support;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
final class AreaResponsibilityHistory
{
public static function closeDuplicateOpenResponsibilities(): int
{
$updated = 0;
$duplicates = DB::table('area_usuario')
->select('area_id', 'usuario_id')
->where('responsable', true)
->whereNull('fecha_fin')
->groupBy('area_id', 'usuario_id')
->havingRaw('COUNT(*) > 1')
->get();
foreach ($duplicates as $duplicate) {
$assignments = DB::table('area_usuario')
->where('area_id', $duplicate->area_id)
->where('usuario_id', $duplicate->usuario_id)
->orderBy('fecha_inicio')
->orderBy('id')
->get()
->values();
for ($index = 0; $index < $assignments->count() - 1; $index++) {
if (! $assignments[$index]->responsable || $assignments[$index]->fecha_fin !== null) {
continue;
}
$nextStart = Carbon::parse($assignments[$index + 1]->fecha_inicio);
DB::table('area_usuario')
->where('id', $assignments[$index]->id)
->update([
'fecha_fin' => $nextStart->copy()->subSecond(),
'updated_at' => now(),
]);
$updated++;
}
}
return $updated;
}
public static function replaceOverlapping(
int $areaId,
string $fechaInicio,
?string $fechaFin,
?int $exceptPivotId = null,
): void {
$inicio = Carbon::parse($fechaInicio);
$fin = $fechaFin ? Carbon::parse($fechaFin) : null;
$query = DB::table('area_usuario')
->where('area_id', $areaId)
->where('responsable', true)
->where(function ($query) use ($inicio): void {
$query->whereNull('fecha_fin')->orWhere('fecha_fin', '>=', $inicio);
});
if ($fin) {
$query->where('fecha_inicio', '<=', $fin);
}
if ($exceptPivotId !== null) {
$query->where('id', '!=', $exceptPivotId);
}
foreach ($query->lockForUpdate()->get() as $responsable) {
self::splitAssignment($responsable, $inicio, $fin);
}
}
private static function splitAssignment(object $assignment, Carbon $inicio, ?Carbon $fin): void
{
$assignmentStart = Carbon::parse($assignment->fecha_inicio);
$assignmentEnd = $assignment->fecha_fin ? Carbon::parse($assignment->fecha_fin) : null;
$segments = [];
if ($assignmentStart->lt($inicio)) {
$segments[] = [$assignmentStart, $inicio->copy()->subSecond(), true];
}
$overlapStart = $assignmentStart->gt($inicio) ? $assignmentStart : $inicio;
$overlapEnd = self::earliestEnd($assignmentEnd, $fin);
$segments[] = [$overlapStart, $overlapEnd, false];
if ($fin && ($assignmentEnd === null || $assignmentEnd->gt($fin))) {
$segments[] = [$fin->copy()->addSecond(), $assignmentEnd, true];
}
[$firstStart, $firstEnd, $firstResponsible] = array_shift($segments);
DB::table('area_usuario')->where('id', $assignment->id)->update([
'fecha_inicio' => $firstStart,
'fecha_fin' => $firstEnd,
'responsable' => $firstResponsible,
'updated_at' => now(),
]);
foreach ($segments as [$segmentStart, $segmentEnd, $segmentResponsible]) {
DB::table('area_usuario')->insert([
'area_id' => $assignment->area_id,
'usuario_id' => $assignment->usuario_id,
'fecha_inicio' => $segmentStart,
'fecha_fin' => $segmentEnd,
'responsable' => $segmentResponsible,
'created_at' => now(),
'updated_at' => now(),
]);
}
}
private static function earliestEnd(?Carbon $first, ?Carbon $second): ?Carbon
{
if ($first === null) {
return $second;
}
if ($second === null) {
return $first;
}
return $first->lte($second) ? $first : $second;
}
}
+35
View File
@@ -0,0 +1,35 @@
<?php
namespace App\Support;
use App\Models\Backup;
use Illuminate\Support\Facades\Storage;
class BackupRetention
{
public static function prune(int $retention): int
{
$idsToKeep = Backup::where('status', 'completed')
->orderByDesc('completed_at')
->limit($retention)
->pluck('id');
$backups = Backup::where('status', 'completed')
->whereNotIn('id', $idsToKeep)
->get();
foreach ($backups as $old) {
$path = "backups/{$old->filename}";
if (Storage::disk('local')->exists($path)) {
Storage::disk('local')->delete($path);
}
$fullPath = storage_path("app/private/{$path}");
if (file_exists($fullPath)) {
@unlink($fullPath);
}
$old->delete();
}
return $backups->count();
}
}
+55
View File
@@ -0,0 +1,55 @@
<?php
namespace App\Support;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
final class HistoricalPeriod
{
public static function inclusiveEnd(?string $value): ?string
{
if ($value === null || $value === '') {
return null;
}
return preg_match('/^\d{4}-\d{2}-\d{2}$/', $value)
? Carbon::parse($value)->endOfDay()->toDateTimeString()
: $value;
}
public static function close(
string $table,
array $scope,
string $startColumn = 'fecha_inicio',
string $endColumn = 'fecha_fin',
array $extraUpdates = [],
bool $dateOnly = false,
): bool {
$query = DB::table($table);
foreach ($scope as $column => $value) {
$query->where($column, $value);
}
$record = $query->firstOrFail();
$now = now();
$comparisonNow = $dateOnly ? $now->copy()->startOfDay() : $now;
if ($record->{$endColumn} && Carbon::parse($record->{$endColumn})->lte($comparisonNow)) {
return false;
}
$start = $record->{$startColumn}
? Carbon::parse($record->{$startColumn})
: $comparisonNow->copy();
$closedAt = $start->gt($comparisonNow) ? $start : $comparisonNow;
$query->update([
$endColumn => $dateOnly ? $closedAt->toDateString() : $closedAt,
...$extraUpdates,
'updated_at' => $now,
]);
return true;
}
}
+186
View File
@@ -0,0 +1,186 @@
<?php
namespace App\Support;
use App\Models\Riesgo;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
final class RiskCalculator
{
public const SCORE_MAP = [
'Bajo' => 1, 'Baja' => 1,
'Medio' => 2, 'Media' => 2,
'Alto' => 3, 'Alta' => 3,
'Crítico' => 4, 'Crítica' => 4,
];
public const CLASSIFICATION = [
[0, 4, 'Bajo'],
[5, 9, 'Medio'],
[10, 19, 'Alto'],
[20, 32, 'Crítico'],
];
public static function levelToInt(string $level): int
{
return self::SCORE_MAP[$level] ?? 1;
}
public static function scoreToLevel(int $score): string
{
foreach (self::CLASSIFICATION as [$min, $max, $label]) {
if ($score >= $min && $score <= $max) {
return $label;
}
}
return 'Crítico';
}
/**
* Calculate risk scores for a single riesgo and return the breakdown.
*/
public static function calculate(Riesgo $riesgo): array
{
$riesgo->loadMissing(['amenaza', 'vulnerabilidad', 'recurso', 'controles']);
$isV0 = self::isVulnerabilityInactive($riesgo);
$a = self::levelToInt($riesgo->amenaza->nivel_de_amenaza ?? 'Bajo');
$v = $isV0 ? 0 : self::levelToInt($riesgo->vulnerabilidad->severidad ?? 'Bajo');
$i = self::levelToInt($riesgo->recurso->impacto ?? 'Bajo');
$c = self::sumControlEffectiveness($riesgo);
$pInherente = $a + $v;
$pResidual = max(0, $pInherente - $c);
$rInherente = $pInherente * $i;
$rResidual = $pResidual * $i;
return [
'is_v0' => $isV0,
'a' => $a,
'v' => $v,
'c' => $c,
'i' => $i,
'p_inherente' => $pInherente,
'p_residual' => $pResidual,
'r_inherente' => $rInherente,
'r_residual' => $rResidual,
'riesgo_inherente' => self::scoreToLevel($rInherente),
'riesgo_residual' => self::scoreToLevel($rResidual),
];
}
/**
* Recalculate and persist scores for a single riesgo.
*/
public static function recalculate(Riesgo $riesgo): Riesgo
{
$result = self::calculate($riesgo);
$riesgo->update([
'riesgo_inherente' => $result['riesgo_inherente'],
'riesgo_residual' => $result['riesgo_residual'],
'probabilidad_inherente' => $result['p_inherente'],
'probabilidad_residual' => $result['p_residual'],
'puntaje_inherente' => $result['r_inherente'],
'puntaje_residual' => $result['r_residual'],
'total_efect' => $result['c'],
'calculado_en' => Carbon::now(),
]);
return $riesgo->fresh();
}
/**
* Recalculate all active riesgos.
*/
public static function recalculateAll(): int
{
return self::recalculateQuery(
Riesgo::query(),
);
}
/**
* Recalculate active risks related to an amenaza.
*/
public static function recalculateForAmenaza(int $amenazaId): int
{
return self::recalculateQuery(
Riesgo::query()->where('amenazas_id', $amenazaId),
);
}
/**
* Recalculate active risks related to a vulnerabilidad.
*/
public static function recalculateForVulnerabilidad(int $vulnerabilidadId): int
{
return self::recalculateQuery(
Riesgo::query()->where('vulnerabilidades_id', $vulnerabilidadId),
);
}
private static function recalculateQuery(Builder $query): int
{
$count = 0;
$query
->where(function (Builder $query): void {
$query->whereNull('fecha_baja')
->orWhere('fecha_baja', '>', Carbon::now());
})
->each(function (Riesgo $riesgo) use (&$count): void {
self::recalculate($riesgo);
$count++;
});
return $count;
}
/**
* Check if the vulnerability-resource historical relationship is no longer active (V=0).
*/
public static function isVulnerabilityInactive(Riesgo $riesgo): bool
{
if (! $riesgo->vulnerabilidades_id || ! $riesgo->recursos_id) {
return false;
}
$pivot = DB::table('recursos_vulnerabilidad')
->where('vulnerabilidad_id', $riesgo->vulnerabilidades_id)
->where('recursos_id', $riesgo->recursos_id)
->latest('fecha_identificacion')
->latest('id')
->first();
if (! $pivot) {
return true;
}
if ($pivot->fecha_fin && Carbon::parse($pivot->fecha_fin)->lte(Carbon::now())) {
return true;
}
return false;
}
public static function sumControlEffectiveness(Riesgo $riesgo): int
{
$now = Carbon::now();
$totalEfectividad = DB::table('riesgo_control')
->join('controles', 'controles.id', '=', 'riesgo_control.control_id')
->where('riesgo_control.riesgo_id', $riesgo->id)
->where('controles.estado', 'Implementado')
->whereNull('riesgo_control.fecha_fin')
->selectRaw("SUM(CASE LOWER(controles.nivel_de_control) WHEN 'fuerte' THEN 4 WHEN 'parcial' THEN 2 WHEN 'debil' THEN 1 ELSE 0 END) as total")
->value('total');
return min((int) ($totalEfectividad ?? 0), 4);
}
}
+37
View File
@@ -0,0 +1,37 @@
<?php
namespace App\Traits;
use App\Models\Auditoria;
use Illuminate\Support\Facades\Auth;
trait LogsAuditoria
{
public static function bootLogsAuditoria()
{
static::created(function ($model) {
static::logAuditoria('created', $model, null, $model->toArray());
});
static::updated(function ($model) {
static::logAuditoria('updated', $model, $model->getOriginal(), $model->getChanges());
});
static::deleted(function ($model) {
static::logAuditoria('deleted', $model, $model->toArray(), null);
});
}
protected static function logAuditoria($accion, $model, $anterior, $nuevo)
{
Auditoria::create([
'user_id' => Auth::id() ?? 1,
'accion' => $accion,
'tabla' => $model->getTable(),
'campo_id' => $model->id,
'valor_anterior' => is_array($anterior) ? json_encode($anterior) : $anterior,
'valor_nuevo' => is_array($nuevo) ? json_encode($nuevo) : $nuevo,
'ip' => request()->ip() ?? '127.0.0.1',
]);
}
}
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env php
<?php
use Symfony\Component\Console\Input\ArgvInput;
define('LARAVEL_START', microtime(true));
// Register the Composer autoloader...
require __DIR__.'/vendor/autoload.php';
// Bootstrap Laravel and handle the command...
$status = (require_once __DIR__.'/bootstrap/app.php')
->handleCommand(new ArgvInput);
exit($status);
+2
View File
@@ -0,0 +1,2 @@
Set shell = CreateObject("WScript.Shell")
shell.Run "cmd /c C:\xampp\htdocs\m-gap\backup-scheduler.bat", 0, True
+3
View File
@@ -0,0 +1,3 @@
@echo off
cd /d "C:\xampp\htdocs\m-gap"
C:\xampp\php\php.exe artisan schedule:run
+39
View File
@@ -0,0 +1,39 @@
<?php
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Inertia\Inertia;
use Symfony\Component\HttpFoundation\Response;
return Application::configure(basePath: dirname(__DIR__))
->withRouting(
web: __DIR__.'/../routes/web.php',
api: __DIR__.'/../routes/api.php',
commands: __DIR__.'/../routes/console.php',
health: '/up',
)
->withMiddleware(function (Middleware $middleware) {
$middleware->web(append: [
\App\Http\Middleware\HandleInertiaRequests::class,
\Illuminate\Http\Middleware\AddLinkHeadersForPreloadedAssets::class,
]);
$middleware->alias([
'role' => \Spatie\Permission\Middleware\RoleMiddleware::class,
]);
$middleware->statefulApi();
})
->withExceptions(function (Exceptions $exceptions) {
$exceptions->respond(function (Response $response, Throwable $exception, Request $request) {
if ($response->getStatusCode() === 403 && ! $request->expectsJson()) {
return Inertia::render('Error', ['status' => 403])
->toResponse($request)
->setStatusCode(403);
}
return $response;
});
})->create();
+2
View File
@@ -0,0 +1,2 @@
*
!.gitignore
+5
View File
@@ -0,0 +1,5 @@
<?php
return [
App\Providers\AppServiceProvider::class,
];
+76
View File
@@ -0,0 +1,76 @@
{
"$schema": "https://getcomposer.org/schema.json",
"name": "laravel/laravel",
"type": "project",
"description": "The skeleton application for the Laravel framework.",
"keywords": ["laravel", "framework"],
"license": "MIT",
"require": {
"php": "^8.2",
"inertiajs/inertia-laravel": "^2.0",
"laravel/framework": "^11.31",
"laravel/sanctum": "^4.0",
"laravel/tinker": "^2.9",
"spatie/laravel-permission": "^6.25",
"tightenco/ziggy": "^2.0"
},
"require-dev": {
"fakerphp/faker": "^1.23",
"laravel/breeze": "^2.3",
"laravel/pail": "^1.1",
"laravel/pint": "^1.13",
"laravel/sail": "^1.26",
"mockery/mockery": "^1.6",
"nunomaduro/collision": "^8.1",
"phpunit/phpunit": "^11.0.1"
},
"autoload": {
"psr-4": {
"App\\": "app/",
"Database\\Factories\\": "database/factories/",
"Database\\Seeders\\": "database/seeders/"
}
},
"autoload-dev": {
"psr-4": {
"Tests\\": "tests/"
}
},
"scripts": {
"post-autoload-dump": [
"Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
"@php artisan package:discover --ansi"
],
"post-update-cmd": [
"@php artisan vendor:publish --tag=laravel-assets --ansi --force"
],
"post-root-package-install": [
"@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
],
"post-create-project-cmd": [
"@php artisan key:generate --ansi",
"@php -r \"file_exists('database/database.sqlite') || touch('database/database.sqlite');\"",
"@php artisan migrate --graceful --ansi"
],
"dev": [
"Composer\\Config::disableProcessTimeout",
"npx concurrently -c \"#93c5fd,#c4b5fd,#fb7185,#fdba74\" \"php artisan serve\" \"php artisan queue:listen --tries=1\" \"php artisan pail --timeout=0\" \"npm run dev\" --names=server,queue,logs,vite"
]
},
"extra": {
"laravel": {
"dont-discover": []
}
},
"config": {
"optimize-autoloader": true,
"preferred-install": "dist",
"sort-packages": true,
"allow-plugins": {
"pestphp/pest-plugin": true,
"php-http/discovery": true
}
},
"minimum-stability": "stable",
"prefer-stable": true
}
Generated
+8586
View File
File diff suppressed because it is too large Load Diff
+126
View File
@@ -0,0 +1,126 @@
<?php
return [
/*
|--------------------------------------------------------------------------
| Application Name
|--------------------------------------------------------------------------
|
| This value is the name of your application, which will be used when the
| framework needs to place the application's name in a notification or
| other UI elements where an application name needs to be displayed.
|
*/
'name' => env('APP_NAME', 'Laravel'),
/*
|--------------------------------------------------------------------------
| Application Environment
|--------------------------------------------------------------------------
|
| This value determines the "environment" your application is currently
| running in. This may determine how you prefer to configure various
| services the application utilizes. Set this in your ".env" file.
|
*/
'env' => env('APP_ENV', 'production'),
/*
|--------------------------------------------------------------------------
| Application Debug Mode
|--------------------------------------------------------------------------
|
| When your application is in debug mode, detailed error messages with
| stack traces will be shown on every error that occurs within your
| application. If disabled, a simple generic error page is shown.
|
*/
'debug' => (bool) env('APP_DEBUG', false),
/*
|--------------------------------------------------------------------------
| Application URL
|--------------------------------------------------------------------------
|
| This URL is used by the console to properly generate URLs when using
| the Artisan command line tool. You should set this to the root of
| the application so that it's available within Artisan commands.
|
*/
'url' => env('APP_URL', 'http://localhost'),
/*
|--------------------------------------------------------------------------
| Application Timezone
|--------------------------------------------------------------------------
|
| Here you may specify the default timezone for your application, which
| will be used by the PHP date and date-time functions. The timezone
| is set to "UTC" by default as it is suitable for most use cases.
|
*/
'timezone' => env('APP_TIMEZONE', 'UTC'),
/*
|--------------------------------------------------------------------------
| Application Locale Configuration
|--------------------------------------------------------------------------
|
| The application locale determines the default locale that will be used
| by Laravel's translation / localization methods. This option can be
| set to any locale for which you plan to have translation strings.
|
*/
'locale' => env('APP_LOCALE', 'es'),
'fallback_locale' => env('APP_FALLBACK_LOCALE', 'en'),
'faker_locale' => env('APP_FAKER_LOCALE', 'en_US'),
/*
|--------------------------------------------------------------------------
| Encryption Key
|--------------------------------------------------------------------------
|
| This key is utilized by Laravel's encryption services and should be set
| to a random, 32 character string to ensure that all encrypted values
| are secure. You should do this prior to deploying the application.
|
*/
'cipher' => 'AES-256-CBC',
'key' => env('APP_KEY'),
'previous_keys' => [
...array_filter(
explode(',', env('APP_PREVIOUS_KEYS', ''))
),
],
/*
|--------------------------------------------------------------------------
| Maintenance Mode Driver
|--------------------------------------------------------------------------
|
| These configuration options determine the driver used to determine and
| manage Laravel's "maintenance mode" status. The "cache" driver will
| allow maintenance mode to be controlled across multiple machines.
|
| Supported drivers: "file", "cache"
|
*/
'maintenance' => [
'driver' => env('APP_MAINTENANCE_DRIVER', 'file'),
'store' => env('APP_MAINTENANCE_STORE', 'database'),
],
];

Some files were not shown because too many files have changed in this diff Show More