Permisos de Usuarios

Pruebas
Producción

Dominio: https://test-api-factura.edw-dev.com

Endpoints para consultar y gestionar los permisos de usuarios en el sistema.

Endpoints Disponibles

GET /api/v1/users/my-permissions - Obtener mis permisos
GET /api/v1/users/me/my-permission - Obtener mi información de permisos

GET /api/v1/users/my-permissions

Obtiene la lista completa de permisos del usuario autenticado.

Información General

Método: GET
Endpoint: /api/v1/users/my-permissions
Autenticación: Requerida (Bearer Token)
Permisos: Usuario autenticado
Caché: Los permisos se cachean por 15 minutos

Headers Requeridos

Accept: application/json
Authorization: Bearer {token}

Ejemplo de Implementación

Solicitud

GET /api/v1/users/my-permissions

Respuesta Exitosa (200)

{
    "message": "Permisos del usuario",
    "status": "OK",
    "payload": {
        "user_id": 123456789,
        "role": {
            "id": 2,
            "name": "Administrador",
            "description": "Administrador del sistema"
        },
        "permissions": [
            {
                "id": 1,
                "name": "create_documents",
                "display_name": "Crear Documentos",
                "description": "Permite crear documentos SRI",
                "category": "documents"
            },
            {
                "id": 2,
                "name": "view_reports",
                "display_name": "Ver Reportes",
                "description": "Permite visualizar reportes del sistema",
                "category": "reports"
            },
            {
                "id": 3,
                "name": "manage_users",
                "display_name": "Gestionar Usuarios",
                "description": "Permite crear, editar y eliminar usuarios",
                "category": "users"
            },
            {
                "id": 4,
                "name": "view_analytics",
                "display_name": "Ver Analíticas",
                "description": "Permite acceder a analíticas avanzadas",
                "category": "analytics"
            }
        ],
        "permission_groups": {
            "documents": [
                "create_documents",
                "edit_documents",
                "delete_documents",
                "view_documents"
            ],
            "users": [
                "manage_users",
                "view_users"
            ],
            "reports": [
                "view_reports",
                "export_reports"
            ],
            "analytics": [
                "view_analytics"
            ]
        },
        "restrictions": {
            "max_documents_per_month": 1000,
            "can_access_api": true,
            "can_export_data": true,
            "allowed_document_types": ["01", "04", "05", "06", "07"]
        },
        "expires_at": null,
        "last_updated": "2025-01-17 10:30:00"
    }
}

Usuario Sin Permisos Especiales (200)

{
    "message": "Permisos del usuario",
    "status": "OK",
    "payload": {
        "user_id": 987654321,
        "role": {
            "id": 1,
            "name": "Usuario Básico",
            "description": "Usuario con permisos básicos"
        },
        "permissions": [
            {
                "id": 1,
                "name": "create_documents",
                "display_name": "Crear Documentos",
                "description": "Permite crear documentos SRI",
                "category": "documents"
            },
            {
                "id": 5,
                "name": "view_own_documents",
                "display_name": "Ver Mis Documentos",
                "description": "Permite ver solo sus propios documentos",
                "category": "documents"
            }
        ],
        "permission_groups": {
            "documents": [
                "create_documents",
                "view_own_documents"
            ]
        },
        "restrictions": {
            "max_documents_per_month": 100,
            "can_access_api": true,
            "can_export_data": false,
            "allowed_document_types": ["01", "04"]
        },
        "expires_at": null,
        "last_updated": "2025-01-17 10:30:00"
    }
}

GET /api/v1/users/me/my-permission

Obtiene información detallada sobre los permisos y el contexto del usuario autenticado.

Información General

Método: GET
Endpoint: /api/v1/users/me/my-permission
Autenticación: Requerida (Bearer Token)
Permisos: Usuario autenticado
Información adicional: Incluye contexto de empresa y gestión

Headers Requeridos

Accept: application/json
Authorization: Bearer {token}

Ejemplo de Implementación

Solicitud

GET /api/v1/users/me/my-permission

Respuesta Exitosa (200)

{
    "message": "Información de permisos del usuario",
    "status": "OK",
    "payload": {
        "user": {
            "uuid": 123456789,
            "name": "Juan",
            "last_name": "Pérez",
            "email": "[email protected]",
            "status": "active"
        },
        "company": {
            "uuid": 987654321,
            "name": "Empresa Ejemplo S.A.",
            "ruc": "0123456789001",
            "address": "Av. Principal 123, Quito",
            "status": "active",
            "plan": "premium"
        },
        "management": {
            "uuid": 555666777,
            "role": {
                "id": 2,
                "name": "Administrador",
                "level": "admin"
            },
            "permissions": [
                "create_documents",
                "view_reports",
                "manage_users",
                "view_analytics",
                "export_data",
                "access_api"
            ],
            "department": "Contabilidad",
            "position": "Contador General",
            "hire_date": "2024-01-15",
            "supervisor_id": null,
            "is_supervisor": true,
            "team_members": [
                {
                    "uuid": 111222333,
                    "name": "María González",
                    "position": "Asistente Contable"
                }
            ]
        },
        "access_control": {
            "allowed_ips": ["192.168.1.0/24", "10.0.0.0/8"],
            "allowed_hours": {
                "start": "08:00",
                "end": "18:00",
                "timezone": "America/Guayaquil"
            },
            "two_factor_enabled": true,
            "session_timeout": 480,
            "max_concurrent_sessions": 3
        },
        "quotas": {
            "documents": {
                "monthly_limit": 1000,
                "current_usage": 245,
                "remaining": 755,
                "reset_date": "2025-02-01"
            },
            "api_calls": {
                "daily_limit": 10000,
                "current_usage": 1250,
                "remaining": 8750,
                "reset_date": "2025-01-18"
            },
            "storage": {
                "limit_gb": 50,
                "used_gb": 12.5,
                "remaining_gb": 37.5
            }
        },
        "features": {
            "advanced_reports": true,
            "bulk_operations": true,
            "api_access": true,
            "white_label": false,
            "priority_support": true,
            "custom_integrations": true
        },
        "last_login": "2025-01-17 09:15:00",
        "permissions_updated_at": "2025-01-15 14:30:00"
    }
}

Ejemplos de Código

# Obtener mis permisos
curl -X GET "https://dev-facturacion.e-dinky.test/api/v1/users/my-permissions" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer {token}"

# Obtener información detallada de permisos
curl -X GET "https://dev-facturacion.e-dinky.test/api/v1/users/me/my-permission" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer {token}"

<?php

use Illuminate\Support\Facades\Http;

$token = 'your-api-token';

// Obtener mis permisos
function getMyPermissions($token) {
    $response = Http::withHeaders([
        'Accept' => 'application/json',
        'Authorization' => 'Bearer ' . $token,
    ])->get('https://dev-facturacion.e-dinky.test/api/v1/users/my-permissions');

    if ($response->successful()) {
        $permissions = $response->json()['payload'];

        echo "Usuario ID: " . $permissions['user_id'] . "\n";
        echo "Rol: " . $permissions['role']['name'] . "\n";
        echo "Permisos totales: " . count($permissions['permissions']) . "\n\n";

        foreach ($permissions['permissions'] as $permission) {
            echo "- " . $permission['display_name'] . " (" . $permission['name'] . ")\n";
        }

        return $permissions;
    } else {
        echo "Error obteniendo permisos: " . $response->json()['message'] . "\n";
        return false;
    }
}

// Obtener información detallada de permisos
function getMyDetailedPermissions($token) {
    $response = Http::withHeaders([
        'Accept' => 'application/json',
        'Authorization' => 'Bearer ' . $token,
    ])->get('https://dev-facturacion.e-dinky.test/api/v1/users/me/my-permission');

    if ($response->successful()) {
        $info = $response->json()['payload'];

        echo "=== INFORMACIÓN DEL USUARIO ===\n";
        echo "Nombre: " . $info['user']['name'] . " " . $info['user']['last_name'] . "\n";
        echo "Email: " . $info['user']['email'] . "\n";
        echo "Empresa: " . $info['company']['name'] . "\n";
        echo "Plan: " . $info['company']['plan'] . "\n\n";

        echo "=== PERMISOS Y ROL ===\n";
        echo "Rol: " . $info['management']['role']['name'] . "\n";
        echo "Departamento: " . $info['management']['department'] . "\n";
        echo "Posición: " . $info['management']['position'] . "\n";
        echo "Es supervisor: " . ($info['management']['is_supervisor'] ? 'Sí' : 'No') . "\n\n";

        echo "=== CUOTAS Y LÍMITES ===\n";
        $quotas = $info['quotas'];
        echo "Documentos: " . $quotas['documents']['current_usage'] . "/" . $quotas['documents']['monthly_limit'] . "\n";
        echo "Llamadas API: " . $quotas['api_calls']['current_usage'] . "/" . $quotas['api_calls']['daily_limit'] . "\n";
        echo "Almacenamiento: " . $quotas['storage']['used_gb'] . "/" . $quotas['storage']['limit_gb'] . " GB\n\n";

        echo "=== CARACTERÍSTICAS HABILITADAS ===\n";
        foreach ($info['features'] as $feature => $enabled) {
            echo "- " . ucfirst(str_replace('_', ' ', $feature)) . ": " . ($enabled ? 'Habilitado' : 'Deshabilitado') . "\n";
        }

        return $info;
    } else {
        echo "Error obteniendo información: " . $response->json()['message'] . "\n";
        return false;
    }
}

// Verificar si tengo un permiso específico
function hasPermission($permissionName, $token) {
    $permissions = getMyPermissions($token);

    if (!$permissions) {
        return false;
    }

    foreach ($permissions['permissions'] as $permission) {
        if ($permission['name'] === $permissionName) {
            return true;
        }
    }

    return false;
}

// Verificar múltiples permisos
function hasPermissions($permissionNames, $token, $requireAll = true) {
    $permissions = getMyPermissions($token);

    if (!$permissions) {
        return false;
    }

    $userPermissions = array_column($permissions['permissions'], 'name');
    $hasPermissions = array_intersect($permissionNames, $userPermissions);

    if ($requireAll) {
        return count($hasPermissions) === count($permissionNames);
    } else {
        return count($hasPermissions) > 0;
    }
}

// Obtener permisos por categoría
function getPermissionsByCategory($category, $token) {
    $permissions = getMyPermissions($token);

    if (!$permissions) {
        return [];
    }

    $categoryPermissions = [];
    foreach ($permissions['permissions'] as $permission) {
        if ($permission['category'] === $category) {
            $categoryPermissions[] = $permission;
        }
    }

    return $categoryPermissions;
}

// Verificar límites de cuota
function checkQuotaLimits($token) {
    $info = getMyDetailedPermissions($token);

    if (!$info) {
        return false;
    }

    $warnings = [];
    $quotas = $info['quotas'];

    // Verificar documentos
    $docUsage = ($quotas['documents']['current_usage'] / $quotas['documents']['monthly_limit']) * 100;
    if ($docUsage > 80) {
        $warnings[] = "Uso de documentos al {$docUsage}% del límite mensual";
    }

    // Verificar API calls
    $apiUsage = ($quotas['api_calls']['current_usage'] / $quotas['api_calls']['daily_limit']) * 100;
    if ($apiUsage > 80) {
        $warnings[] = "Uso de API al {$apiUsage}% del límite diario";
    }

    // Verificar almacenamiento
    $storageUsage = ($quotas['storage']['used_gb'] / $quotas['storage']['limit_gb']) * 100;
    if ($storageUsage > 80) {
        $warnings[] = "Uso de almacenamiento al {$storageUsage}%";
    }

    return $warnings;
}

// Ejemplos de uso

// Obtener mis permisos
$myPermissions = getMyPermissions($token);

// Obtener información detallada
$detailedInfo = getMyDetailedPermissions($token);

// Verificar permiso específico
if (hasPermission('create_documents', $token)) {
    echo "Puedo crear documentos\n";
}

// Verificar múltiples permisos
$requiredPermissions = ['create_documents', 'view_reports'];
if (hasPermissions($requiredPermissions, $token)) {
    echo "Tengo todos los permisos requeridos\n";
}

// Obtener permisos de documentos
$documentPermissions = getPermissionsByCategory('documents', $token);
echo "Permisos de documentos: " . count($documentPermissions) . "\n";

// Verificar límites
$warnings = checkQuotaLimits($token);
if (!empty($warnings)) {
    echo "Advertencias de cuota:\n";
    foreach ($warnings as $warning) {
        echo "- {$warning}\n";
    }
}

const axios = require('axios');

const token = 'your-api-token';

const headers = {
    'Accept': 'application/json',
    'Authorization': `Bearer ${token}`
};

// Obtener mis permisos
const getMyPermissions = async () => {
    try {
        const response = await axios.get('https://dev-facturacion.e-dinky.test/api/v1/users/my-permissions', {
            headers
        });

        const permissions = response.data.payload;

        console.log(`Usuario ID: ${permissions.user_id}`);
        console.log(`Rol: ${permissions.role.name}`);
        console.log(`Permisos totales: ${permissions.permissions.length}\n`);

        permissions.permissions.forEach(permission => {
            console.log(`- ${permission.display_name} (${permission.name})`);
        });

        return permissions;
    } catch (error) {
        console.error('Error obteniendo permisos:', error.response?.data?.message || error.message);
        throw error;
    }
};

// Obtener información detallada de permisos
const getMyDetailedPermissions = async () => {
    try {
        const response = await axios.get('https://dev-facturacion.e-dinky.test/api/v1/users/me/my-permission', {
            headers
        });

        const info = response.data.payload;

        console.log('=== INFORMACIÓN DEL USUARIO ===');
        console.log(`Nombre: ${info.user.name} ${info.user.last_name}`);
        console.log(`Email: ${info.user.email}`);
        console.log(`Empresa: ${info.company.name}`);
        console.log(`Plan: ${info.company.plan}\n`);

        console.log('=== PERMISOS Y ROL ===');
        console.log(`Rol: ${info.management.role.name}`);
        console.log(`Departamento: ${info.management.department}`);
        console.log(`Posición: ${info.management.position}`);
        console.log(`Es supervisor: ${info.management.is_supervisor ? 'Sí' : 'No'}\n`);

        console.log('=== CUOTAS Y LÍMITES ===');
        const quotas = info.quotas;
        console.log(`Documentos: ${quotas.documents.current_usage}/${quotas.documents.monthly_limit}`);
        console.log(`Llamadas API: ${quotas.api_calls.current_usage}/${quotas.api_calls.daily_limit}`);
        console.log(`Almacenamiento: ${quotas.storage.used_gb}/${quotas.storage.limit_gb} GB\n`);

        console.log('=== CARACTERÍSTICAS HABILITADAS ===');
        Object.entries(info.features).forEach(([feature, enabled]) => {
            const featureName = feature.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
            console.log(`- ${featureName}: ${enabled ? 'Habilitado' : 'Deshabilitado'}`);
        });

        return info;
    } catch (error) {
        console.error('Error obteniendo información:', error.response?.data?.message || error.message);
        throw error;
    }
};

// Verificar si tengo un permiso específico
const hasPermission = async (permissionName) => {
    try {
        const permissions = await getMyPermissions();
        return permissions.permissions.some(p => p.name === permissionName);
    } catch (error) {
        console.error('Error verificando permiso:', error.message);
        return false;
    }
};

// Verificar múltiples permisos
const hasPermissions = async (permissionNames, requireAll = true) => {
    try {
        const permissions = await getMyPermissions();
        const userPermissions = permissions.permissions.map(p => p.name);
        const hasPermissions = permissionNames.filter(p => userPermissions.includes(p));

        if (requireAll) {
            return hasPermissions.length === permissionNames.length;
        } else {
            return hasPermissions.length > 0;
        }
    } catch (error) {
        console.error('Error verificando permisos:', error.message);
        return false;
    }
};

// Obtener permisos por categoría
const getPermissionsByCategory = async (category) => {
    try {
        const permissions = await getMyPermissions();
        return permissions.permissions.filter(p => p.category === category);
    } catch (error) {
        console.error('Error obteniendo permisos por categoría:', error.message);
        return [];
    }
};

// Verificar límites de cuota
const checkQuotaLimits = async () => {
    try {
        const info = await getMyDetailedPermissions();
        const warnings = [];
        const quotas = info.quotas;

        // Verificar documentos
        const docUsage = (quotas.documents.current_usage / quotas.documents.monthly_limit) * 100;
        if (docUsage > 80) {
            warnings.push(`Uso de documentos al ${docUsage.toFixed(1)}% del límite mensual`);
        }

        // Verificar API calls
        const apiUsage = (quotas.api_calls.current_usage / quotas.api_calls.daily_limit) * 100;
        if (apiUsage > 80) {
            warnings.push(`Uso de API al ${apiUsage.toFixed(1)}% del límite diario`);
        }

        // Verificar almacenamiento
        const storageUsage = (quotas.storage.used_gb / quotas.storage.limit_gb) * 100;
        if (storageUsage > 80) {
            warnings.push(`Uso de almacenamiento al ${storageUsage.toFixed(1)}%`);
        }

        return warnings;
    } catch (error) {
        console.error('Error verificando límites:', error.message);
        return [];
    }
};

// Clase para gestión de permisos
class PermissionManager {
    constructor(token) {
        this.token = token;
        this.permissions = null;
        this.detailedInfo = null;
        this.lastUpdate = null;
    }

    async loadPermissions(forceRefresh = false) {
        const now = new Date();
        const cacheExpiry = 15 * 60 * 1000; // 15 minutos

        if (!forceRefresh && this.permissions && this.lastUpdate &&
            (now - this.lastUpdate) < cacheExpiry) {
            return this.permissions;
        }

        this.permissions = await getMyPermissions();
        this.lastUpdate = now;
        return this.permissions;
    }

    async can(permissionName) {
        const permissions = await this.loadPermissions();
        return permissions.permissions.some(p => p.name === permissionName);
    }

    async canAny(permissionNames) {
        const permissions = await this.loadPermissions();
        const userPermissions = permissions.permissions.map(p => p.name);
        return permissionNames.some(p => userPermissions.includes(p));
    }

    async canAll(permissionNames) {
        const permissions = await this.loadPermissions();
        const userPermissions = permissions.permissions.map(p => p.name);
        return permissionNames.every(p => userPermissions.includes(p));
    }

    async getRole() {
        const permissions = await this.loadPermissions();
        return permissions.role;
    }

    async getQuotaUsage() {
        if (!this.detailedInfo) {
            this.detailedInfo = await getMyDetailedPermissions();
        }
        return this.detailedInfo.quotas;
    }

    async isFeatureEnabled(featureName) {
        if (!this.detailedInfo) {
            this.detailedInfo = await getMyDetailedPermissions();
        }
        return this.detailedInfo.features[featureName] || false;
    }
}

// Ejemplos de uso
(async () => {
    try {
        // Obtener mis permisos
        const myPermissions = await getMyPermissions();

        // Obtener información detallada
        const detailedInfo = await getMyDetailedPermissions();

        // Verificar permiso específico
        const canCreateDocs = await hasPermission('create_documents');
        console.log(`\nPuedo crear documentos: ${canCreateDocs ? 'Sí' : 'No'}`);

        // Verificar múltiples permisos
        const requiredPermissions = ['create_documents', 'view_reports'];
        const hasAllPermissions = await hasPermissions(requiredPermissions);
        console.log(`Tengo todos los permisos requeridos: ${hasAllPermissions ? 'Sí' : 'No'}`);

        // Obtener permisos de documentos
        const documentPermissions = await getPermissionsByCategory('documents');
        console.log(`\nPermisos de documentos: ${documentPermissions.length}`);

        // Verificar límites
        const warnings = await checkQuotaLimits();
        if (warnings.length > 0) {
            console.log('\nAdvertencias de cuota:');
            warnings.forEach(warning => console.log(`- ${warning}`));
        }

        // Usar PermissionManager
        const pm = new PermissionManager(token);

        const canManageUsers = await pm.can('manage_users');
        console.log(`\nPuedo gestionar usuarios: ${canManageUsers ? 'Sí' : 'No'}`);

        const role = await pm.getRole();
        console.log(`Mi rol: ${role.name}`);

        const hasAdvancedReports = await pm.isFeatureEnabled('advanced_reports');
        console.log(`Reportes avanzados habilitados: ${hasAdvancedReports ? 'Sí' : 'No'}`);

    } catch (error) {
        console.error('Error en operaciones:', error.message);
    }
})();

Categorías de Permisos

1. Documentos (`documents`)

create_documents - Crear documentos SRI
edit_documents - Editar documentos
delete_documents - Eliminar documentos
view_documents - Ver documentos
view_own_documents - Ver solo mis documentos
approve_documents - Aprobar documentos
send_documents - Enviar documentos al SRI

2. Usuarios (`users`)

manage_users - Gestionar usuarios
view_users - Ver usuarios
create_users - Crear usuarios
edit_users - Editar usuarios
delete_users - Eliminar usuarios
assign_roles - Asignar roles

3. Reportes (`reports`)

view_reports - Ver reportes
create_reports - Crear reportes
export_reports - Exportar reportes
schedule_reports - Programar reportes
share_reports - Compartir reportes

4. Analíticas (`analytics`)

view_analytics - Ver analíticas
advanced_analytics - Analíticas avanzadas
real_time_analytics - Analíticas en tiempo real
custom_dashboards - Dashboards personalizados

5. Sistema (`system`)

admin_panel - Panel de administración
system_settings - Configuraciones del sistema
backup_restore - Backup y restauración
audit_logs - Logs de auditoría
api_management - Gestión de API

6. Empresa (`company`)

manage_company - Gestionar empresa
view_company_data - Ver datos de empresa
edit_company_settings - Editar configuraciones
manage_billing - Gestionar facturación

Niveles de Roles

1. Super Administrador

Acceso completo al sistema
Gestión de múltiples empresas
Configuraciones globales
Sin restricciones de cuota

2. Administrador

Gestión completa de su empresa
Todos los permisos de documentos
Gestión de usuarios de su empresa
Reportes y analíticas avanzadas

3. Contador

Creación y gestión de documentos
Reportes contables
Consulta de información fiscal
Limitaciones según plan

4. Usuario Básico

Creación de documentos básicos
Consulta de sus propios documentos
Reportes básicos
Cuotas limitadas

5. Solo Lectura

Solo consulta de información
Sin permisos de creación
Reportes de solo lectura
Acceso limitado

Restricciones y Cuotas

1. Límites de Documentos

// Verificar límite de documentos
const checkDocumentLimit = async () => {
    const info = await getMyDetailedPermissions();
    const quota = info.quotas.documents;

    if (quota.current_usage >= quota.monthly_limit) {
        throw new Error('Límite mensual de documentos alcanzado');
    }

    const remaining = quota.monthly_limit - quota.current_usage;
    console.log(`Documentos restantes este mes: ${remaining}`);

    return remaining;
};

2. Límites de API

// Verificar límite de API
function checkApiLimit($token) {
    $info = getMyDetailedPermissions($token);
    $quota = $info['quotas']['api_calls'];

    if ($quota['current_usage'] >= $quota['daily_limit']) {
        throw new Exception('Límite diario de llamadas API alcanzado');
    }

    $remaining = $quota['daily_limit'] - $quota['current_usage'];
    echo "Llamadas API restantes hoy: {$remaining}\n";

    return $remaining;
}

3. Control de Acceso por IP

// Verificar acceso por IP
const checkIPAccess = async (clientIP) => {
    const info = await getMyDetailedPermissions();
    const allowedIPs = info.access_control.allowed_ips;

    const isAllowed = allowedIPs.some(range => {
        // Verificar si la IP está en el rango permitido
        return isIPInRange(clientIP, range);
    });

    if (!isAllowed) {
        throw new Error('Acceso denegado desde esta IP');
    }

    return true;
};

4. Control de Horarios

// Verificar horario de acceso
function checkAccessHours($token) {
    $info = getMyDetailedPermissions($token);
    $accessControl = $info['access_control'];

    $timezone = new DateTimeZone($accessControl['allowed_hours']['timezone']);
    $now = new DateTime('now', $timezone);
    $currentTime = $now->format('H:i');

    $startTime = $accessControl['allowed_hours']['start'];
    $endTime = $accessControl['allowed_hours']['end'];

    if ($currentTime < $startTime || $currentTime > $endTime) {
        throw new Exception('Acceso fuera del horario permitido');
    }

    return true;
}

Códigos de Respuesta

Código	Descripción	Acción
`200`	Permisos obtenidos exitosamente	Procesar información
`401`	Token inválido	Renovar autenticación
`403`	Sin permisos	Verificar acceso
`429`	Límite de cuota excedido	Esperar o actualizar plan
`500`	Error del servidor	Reintentar más tarde

Mejores Prácticas

1. Cache de Permisos

// Implementar cache inteligente
class PermissionCache {
    constructor(ttl = 15 * 60 * 1000) { // 15 minutos
        this.cache = new Map();
        this.ttl = ttl;
    }

    set(key, value) {
        this.cache.set(key, {
            value,
            timestamp: Date.now()
        });
    }

    get(key) {
        const item = this.cache.get(key);
        if (!item) return null;

        if (Date.now() - item.timestamp > this.ttl) {
            this.cache.delete(key);
            return null;
        }

        return item.value;
    }

    clear() {
        this.cache.clear();
    }
}

2. Verificación Reactiva

// Verificar permisos en tiempo real
const createPermissionChecker = (token) => {
    const cache = new PermissionCache();

    return {
        async can(permission) {
            const cached = cache.get('permissions');
            if (cached) {
                return cached.permissions.some(p => p.name === permission);
            }

            const permissions = await getMyPermissions();
            cache.set('permissions', permissions);

            return permissions.permissions.some(p => p.name === permission);
        },

        invalidate() {
            cache.clear();
        }
    };
};

3. Middleware de Permisos

// Middleware para verificar permisos
class PermissionMiddleware {
    public function handle($request, $next, $permission) {
        $token = $request->bearerToken();

        if (!$this->hasPermission($permission, $token)) {
            return response()->json([
                'message' => 'Sin permisos suficientes',
                'required_permission' => $permission
            ], 403);
        }

        return $next($request);
    }

    private function hasPermission($permission, $token) {
        // Verificar permiso usando la API
        return hasPermission($permission, $token);
    }
}

Casos de Uso Específicos

1. Dashboard Dinámico

// Crear dashboard basado en permisos
const createDynamicDashboard = async () => {
    const permissions = await getMyPermissions();
    const features = await getMyDetailedPermissions();

    const dashboardItems = [];

    // Agregar elementos según permisos
    if (permissions.permissions.some(p => p.name === 'create_documents')) {
        dashboardItems.push({
            title: 'Crear Documentos',
            icon: 'document-plus',
            route: '/documents/create'
        });
    }

    if (permissions.permissions.some(p => p.name === 'view_reports')) {
        dashboardItems.push({
            title: 'Reportes',
            icon: 'chart-bar',
            route: '/reports'
        });
    }

    if (features.features.advanced_reports) {
        dashboardItems.push({
            title: 'Reportes Avanzados',
            icon: 'chart-line',
            route: '/reports/advanced'
        });
    }

    return dashboardItems;
};

2. Validación de Formularios

// Validar campos según permisos
const validateFormFields = async (formData) => {
    const permissions = await getMyPermissions();
    const userPermissions = permissions.permissions.map(p => p.name);

    const validatedData = { ...formData };

    // Solo administradores pueden cambiar el estado
    if (!userPermissions.includes('manage_users') && validatedData.status) {
        delete validatedData.status;
    }

    // Solo supervisores pueden asignar roles
    if (!userPermissions.includes('assign_roles') && validatedData.role_id) {
        delete validatedData.role_id;
    }

    return validatedData;
};

3. Menú Contextual

// Generar menú basado en permisos
function generateContextualMenu($token) {
    $permissions = getMyPermissions($token);
    $userPermissions = array_column($permissions['permissions'], 'name');

    $menu = [];

    // Menú de documentos
    if (in_array('view_documents', $userPermissions)) {
        $documentsMenu = ['title' => 'Documentos', 'items' => []];

        if (in_array('create_documents', $userPermissions)) {
            $documentsMenu['items'][] = ['title' => 'Crear', 'route' => '/documents/create'];
        }

        if (in_array('view_documents', $userPermissions)) {
            $documentsMenu['items'][] = ['title' => 'Listar', 'route' => '/documents'];
        }

        $menu[] = $documentsMenu;
    }

    // Menú de usuarios (solo administradores)
    if (in_array('manage_users', $userPermissions)) {
        $menu[] = [
            'title' => 'Usuarios',
            'items' => [
                ['title' => 'Listar', 'route' => '/users'],
                ['title' => 'Crear', 'route' => '/users/create']
            ]
        ];
    }

    return $menu;
}

Notas Importantes

🔐 Seguridad: Los permisos se verifican en cada solicitud
⚡ Cache: Implementar cache para mejorar rendimiento
🔄 Tiempo real: Los permisos se actualizan en tiempo real
📊 Cuotas: Respetar límites de cuota según el plan
🎯 Granularidad: Permisos granulares para control preciso
🚫 Restricciones: Verificar restricciones de IP y horario
📱 Responsive: Adaptar interfaz según permisos
🔍 Auditoría: Registrar accesos y cambios de permisos
💼 Contexto: Considerar contexto empresarial
🔗 Jerarquía: Respetar jerarquía de roles y permisos

Permisos de Usuarios

Permisos de Usuarios

Endpoints Disponibles

GET /api/v1/users/my-permissions

Información General

Headers Requeridos

Ejemplo de Implementación

Solicitud

Respuesta Exitosa (200)

Usuario Sin Permisos Especiales (200)

GET /api/v1/users/me/my-permission

Información General

Headers Requeridos

Ejemplo de Implementación

Solicitud

Respuesta Exitosa (200)

Ejemplos de Código

Categorías de Permisos

1. Documentos (documents)

2. Usuarios (users)

3. Reportes (reports)

4. Analíticas (analytics)

5. Sistema (system)

6. Empresa (company)

Niveles de Roles

1. Super Administrador

2. Administrador

3. Contador

4. Usuario Básico

5. Solo Lectura

Restricciones y Cuotas

1. Límites de Documentos

2. Límites de API

3. Control de Acceso por IP

4. Control de Horarios

Códigos de Respuesta

Mejores Prácticas

1. Cache de Permisos

2. Verificación Reactiva

3. Middleware de Permisos

Casos de Uso Específicos

1. Dashboard Dinámico

2. Validación de Formularios

3. Menú Contextual

Notas Importantes

1. Documentos (`documents`)

2. Usuarios (`users`)

3. Reportes (`reports`)

4. Analíticas (`analytics`)

5. Sistema (`system`)

6. Empresa (`company`)