@softdin/portal-admin 0.0.0-stage → 0.2.0

package/dist-lib/types/lib/portal-empleado.d.ts

@@ -0,0 +1,32 @@
+import type { EstadoSolicitudPortal, SolicitudPortal } from '../services/portal-empleado.service';
+/** Estado de una solicitud del portal, como lo ve nómina. */
+export declare const ESTADOS_SOLICITUD_PORTAL: Record<EstadoSolicitudPortal, {
+    texto: string;
+    clase: string;
+}>;
+/** `2026-11-10` o `2026-11-10 00:00:00` → `10/11/2026`. */
+export declare function fechaCorta(valor: string | null): string;
+/**
+ * Novedad que SoftDIN crea al aprobar, por tipo. Es informativo: el empleado
+ * elige el concepto entre los que SoftDIN tiene configurados para su grupo de
+ * nómina, y la configuración vive allá.
+ */
+export declare function conceptoDeTipo(tipo: string): string;
+/** Nombre legible del tipo (el que trae el portal en minúsculas y con guion bajo). */
+export declare const NOMBRES_TIPO_SOLICITUD: Record<string, string>;
+export declare function nombreTipoSolicitud(tipo: string): string;
+/** Incapacidad y licencias: llevan soporte (certificado médico, registro civil) que nómina revisa en SoftDIN. */
+export declare const TIPOS_CON_SOPORTE: readonly ["incapacidad", "licencia_maternidad", "licencia_paternidad"];
+export declare function esTipoConSoporte(tipo: string): boolean;
+/** Cuándo pide soporte el tipo, para la tabla de tipos (la regla vive en SoftDIN). */
+export declare function soporteDeTipo(tipo: string): string | null;
+/**
+ * Estado del soporte de una solicitud. El documento (dato de salud) está solo en SoftDIN, reservado en el
+ * expediente del empleado: aquí no se muestra ni se descarga.
+ */
+export declare function estadoSoporte(s: Pick<SolicitudPortal, 'tipo' | 'tiene_soporte' | 'soporte_pendiente' | 'soporte_en_envio'>): {
+    texto: string;
+    pendiente: boolean;
+} | null;
+/** Datos no clínicos de la incapacidad o licencia, en una línea. */
+export declare function datosNoClinicos(s: Pick<SolicitudPortal, 'origen' | 'es_prorroga' | 'fecha_parto'>): string | null;

package/dist-lib/types/modulo.d.ts

@@ -0,0 +1,31 @@
+import type { RouteRecordRaw, Router } from 'vue-router';
+import { type OpcionesPortalAdmin } from './portal-admin/tipos';
+/**
+ * Punto de entrada de `@softdin/portal-admin`: el portal administrativo (Gestión del Portal)
+ * como módulo que se monta en una app Vue con su router y su Pinia. Lo usan la app
+ * independiente (gestionportal.dinsoft.online, ingreso con usuario y contraseña) y
+ * softdin-central (ingreso por SSO de superusuarios).
+ */
+export type { AsercionSso, NombreRutaPortal, OpcionesPortalAdmin, ProveedorSesionSso, } from './portal-admin/tipos';
+export { RUTAS_PORTAL } from './portal-admin/tipos';
+export { crearRutasPortalAdmin, guardiaPortalAdmin } from './portal-admin/rutas';
+export type { OpcionesRutas } from './portal-admin/rutas';
+/** Store de la sesión del portal (id `portal-auth`), aparte del `auth` de la app anfitriona. */
+export { useAuthStore as usePortalAuthStore } from './stores/auth.store';
+/** Cliente interno elegido en la barra (id `portal-cliente-interno`). */
+export { useClienteInternoStore as usePortalClienteInternoStore } from './stores/cliente-interno.store';
+export type { ClienteRrhh, DatosSesion, RespuestaLogin, Sesion, UsuarioRrhh } from './services/auth.service';
+/** Cliente axios del portal (base `${apiUrl}/rrhh`), separado del de la app anfitriona. */
+export { api as portalApi } from './services/api';
+export interface PortalAdminInstalado {
+    /** Rutas registradas (por si la app quiere listarlas o enlazarlas). */
+    rutas: RouteRecordRaw[];
+    /** Cierra la sesión del portal (`rrhh/auth/logout`) si hay una; nunca falla. */
+    cerrarSesion(): Promise<void>;
+}
+/**
+ * Configura el cliente HTTP del portal, registra sus rutas bajo `basePath` (y bajo
+ * `rutaPadre`, si se da) y su guardia. Debe llamarse con Pinia ya instalada y antes de
+ * `app.use(router)` para que la primera navegación ya encuentre las rutas.
+ */
+export declare function instalarPortalAdmin(router: Router, opciones?: OpcionesPortalAdmin): PortalAdminInstalado;

package/dist-lib/types/portal-admin/config.d.ts

@@ -0,0 +1,17 @@
+import type { ProveedorSesionSso } from './tipos';
+/**
+ * Configuración en curso del módulo. Una app monta un solo portal administrativo, así que es
+ * un objeto del módulo (como el cliente axios) y `instalarPortalAdmin` lo llena.
+ */
+export interface ConfigPortalAdmin {
+    basePath: string;
+    sesion: ProveedorSesionSso | null;
+    alSalir: (() => void) | null;
+    /** Ver `OpcionesPortalAdmin.cambioDeTenant`. */
+    cambioDeTenant: boolean;
+}
+export declare const configPortal: ConfigPortalAdmin;
+/** `'/central/portal/'` → `'/central/portal'`; `''` o `'/'` → `'/'`. */
+export declare function normalizarBasePath(base: string | undefined): string;
+/** Une la base con un tramo: `('/', 'ingreso')` → `'/ingreso'`. */
+export declare function unirRuta(base: string, tramo: string): string;

package/dist-lib/types/portal-admin/rutas.d.ts

@@ -0,0 +1,17 @@
+import type { RouteLocationNormalized, RouteLocationRaw, RouteRecordRaw } from 'vue-router';
+export interface OpcionesRutas {
+    basePath?: string;
+    /** Con SSO se registra además la pantalla de ingreso (`portal-ingreso`). */
+    conSso?: boolean;
+    metaRutas?: Record<string, unknown>;
+}
+/**
+ * Rutas del portal administrativo. Todas llevan `meta.portalAdmin` (así la guardia sabe que
+ * son suyas) y nombres con prefijo `portal-` para no chocar con los de la app que las monta.
+ */
+export declare function crearRutasPortalAdmin(opciones?: OpcionesRutas): RouteRecordRaw[];
+/**
+ * Guardia de las rutas del módulo (las demás pasan sin tocarlas): sin sesión al ingreso, una
+ * verificación de `rrhh/me` por carga y las pantallas de solo administradores.
+ */
+export declare function guardiaPortalAdmin(to: RouteLocationNormalized): Promise<true | RouteLocationRaw>;

package/dist-lib/types/portal-admin/tipos.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Tipos públicos de `@softdin/portal-admin`. Este archivo no importa nada con el alias `@/`
+ * a propósito: es lo que ven las apps que consumen el paquete (sus `.d.ts`).
+ */
+/** Lo que entrega softdin-api en `POST /api/v1/admin/portal/sso`. */
+export interface AsercionSso {
+    asercion: string;
+    /** Segundos de vigencia (hoy 60). */
+    expira_en?: number;
+    /** Base del API del portal (`…/api/v1`) o `null` si softdin-api no la tiene configurada. */
+    portal_api_url?: string | null;
+}
+/**
+ * Proveedor de sesión por SSO (softdin-central). El módulo le pide una aserción NUEVA cada vez
+ * que necesita un token: al entrar, al elegir cliente y al renovar tras un 401. Las aserciones
+ * son de un solo uso y duran 60 s, así que nunca se reutilizan.
+ */
+export interface ProveedorSesionSso {
+    obtenerAsercion(): Promise<AsercionSso>;
+}
+export interface OpcionesPortalAdmin {
+    /**
+     * Base del API del portal, p. ej. `https://apiportal.dinsoft.shop/api/v1` (el módulo agrega
+     * `/rrhh`). Con SSO puede omitirse: se usa `portal_api_url` de la primera aserción.
+     */
+    apiUrl?: string | null;
+    /** Dónde cuelgan las pantallas: `'/'` en la app independiente, `'/central/portal'` en central. */
+    basePath?: string;
+    /** Nombre de una ruta existente bajo la que se registran (p. ej. el layout de central). */
+    rutaPadre?: string;
+    /** Meta que se agrega a cada ruta del módulo (p. ej. `{ module: 'Portal de autogestión' }`). */
+    metaRutas?: Record<string, unknown>;
+    /** Con SSO: el token del portal se obtiene con aserciones y se renueva en silencio en un 401. */
+    sesion?: ProveedorSesionSso | null;
+    /**
+     * La sesión del portal terminó y no se pudo renovar (401/403). Por defecto: limpiar la sesión
+     * y llevar al ingreso (SSO) o a la ruta `login` (app independiente).
+     */
+    alExpirar?: (() => void) | null;
+    /** Tras «Salir» en el menú de usuario. Por defecto, la ruta `login`. */
+    alSalir?: (() => void) | null;
+    /**
+     * Si la barra ofrece cambiar de tenant cuando el usuario tiene varios (por defecto, sí).
+     * `false` en softdin-tenant: el SSO de ámbito tenant entrega una sesión solo del tenant de
+     * la app, y cambiarlo desde el portal la sacaría de ese ámbito.
+     */
+    cambioDeTenant?: boolean;
+}
+/** Nombres de las rutas del módulo: siempre con el prefijo `portal-`. */
+export declare const RUTAS_PORTAL: {
+    readonly inicio: "portal-inicio";
+    readonly ingreso: "portal-ingreso";
+    readonly solicitudes: "portal-solicitudes";
+    readonly certificados: "portal-certificados";
+    readonly empleados: "portal-empleados";
+    readonly tiposSolicitud: "portal-tipos-solicitud";
+    readonly homologacion: "portal-homologacion";
+    readonly carnet: "portal-carnet";
+    readonly cartelera: "portal-cartelera";
+    readonly chat: "portal-chat";
+    readonly chatConfiguracion: "portal-chat-configuracion";
+    readonly chatRespuestas: "portal-chat-respuestas";
+    readonly chatInforme: "portal-chat-informe";
+    readonly chatConocimiento: "portal-chat-conocimiento";
+    readonly chatConversacion: "portal-chat-conversacion";
+    readonly auditoria: "portal-auditoria";
+};
+export type NombreRutaPortal = (typeof RUTAS_PORTAL)[keyof typeof RUTAS_PORTAL];

package/dist-lib/types/router/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Router de la app independiente (gestionportal): aquí solo viven el ingreso con usuario y
+ * contraseña y sus pantallas públicas. Las del portal (`portal-*`) las registra
+ * `instalarPortalAdmin` en `main.ts`, igual que en softdin-central.
+ */
+declare const router: import("vue-router")._RouterClassic;
+export default router;

package/dist-lib/types/services/api.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Cliente HTTP de Gestión del Portal (softdin-portal-api, rutas `/rrhh`). Esta
+ * app ya no habla con softdin-api: el usuario, el token y el cliente son del
+ * portal.
+ *
+ * La base no sale de `import.meta.env` aquí: este archivo también se publica en
+ * `@softdin/portal-admin` y Vite congelaría en el paquete la URL con la que se compiló.
+ * La pone quien instala el módulo (`configurarApiUrl`).
+ */
+export declare const api: import("axios").AxiosInstance;
+/** `https://apiportal…/api/v1` → base `…/api/v1/rrhh`. */
+export declare function configurarApiUrl(apiUrl: string): void;
+/**
+ * Con SSO la base puede venir en la aserción (`portal_api_url`) y no en la configuración de
+ * la app: se recuerda para que, al recargar con el token guardado, las peticiones no salgan
+ * contra el propio origen antes de la siguiente aserción.
+ */
+export declare function recordarApiUrl(apiUrl: string): void;
+export declare function apiUrlRecordada(): string | null;
+export declare function apiUrlConfigurada(): boolean;
+/** Mensaje del 403 de softdin-portal-api cuando la escritura es de un cliente interno no permitido. */
+export declare const MENSAJE_FUERA_DE_ALCANCE = "No tiene acceso a ese cliente.";
+/**
+ * `token`: el de la sesión. `alExpirar`: 401 con sesión abierta (token vencido,
+ * usuario desactivado). Un 403 (cliente desactivado o sin acceso) también cierra.
+ * `renovar` (SSO): ante un 401 se pide un token nuevo una sola vez y se repite la petición;
+ * si no se puede, entonces sí `alExpirar`. Llamarla otra vez reemplaza los interceptores.
+ */
+export declare function setupApiInterceptors(token: () => string | null, alExpirar: () => void, renovar?: (() => Promise<boolean>) | null): void;

package/dist-lib/types/services/auditoria.service.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Auditoría del portal (softdin-portal-api, grupo `rrhh`, `auditoria` y `auditoria/exportar`).
+ * Solo la ve un administrador del cliente de la sesión; a los demás el servidor responde 403.
+ * Los registros son solo del cliente (tenant) de la sesión.
+ */
+export type ActorTipo = 'empleado' | 'rrhh' | 'conductor' | 'softdin' | 'anonimo';
+export type ResultadoAuditoria = 'exito' | 'fallo' | 'rechazado';
+export interface RegistroAuditoria {
+    id: number;
+    /** Hora de Colombia, como la guarda el servidor (`YYYY-MM-DD HH:MM:SS(.mmm)` o ISO). */
+    ocurrido_en: string;
+    actor: {
+        tipo: ActorTipo;
+        id: number | string | null;
+        nombre: string | null;
+        identificacion: string | null;
+    };
+    cliente_interno: {
+        id: number;
+        nombre: string;
+    } | null;
+    accion: string;
+    etiqueta: string | null;
+    recurso: {
+        tipo: string | null;
+        id: string | number | null;
+    } | null;
+    resultado: ResultadoAuditoria;
+    estado_http: number | null;
+    ip: string | null;
+    user_agent: string | null;
+    /** Parámetros ya saneados por el servidor (sin secretos, PII enmascarada). */
+    detalle: Record<string, unknown> | unknown[] | null;
+}
+export interface AccionAuditoria {
+    clave: string;
+    etiqueta: string;
+}
+export interface FiltrosAuditoria {
+    cliente_interno_id?: number | null;
+    actor_tipo?: ActorTipo | '';
+    accion?: string;
+    resultado?: ResultadoAuditoria | '';
+    desde?: string;
+    hasta?: string;
+    q?: string;
+}
+export interface PaginaAuditoria {
+    data: RegistroAuditoria[];
+    meta: {
+        pagina: number;
+        por_pagina: number;
+        total: number;
+    };
+    acciones: AccionAuditoria[];
+}
+/** Solo los filtros con valor: el servidor no recibe `accion=` vacíos. */
+export declare function parametrosAuditoria(f: FiltrosAuditoria): Record<string, string | number>;
+export declare const auditoriaService: {
+    listar(filtros: FiltrosAuditoria, pagina?: number, porPagina?: number): Promise<PaginaAuditoria>;
+    /** CSV UTF-8 con BOM (abre bien en Excel), con los mismos filtros del listado. */
+    exportar(filtros: FiltrosAuditoria): Promise<Blob>;
+};

package/dist-lib/types/services/auth.service.d.ts

@@ -0,0 +1,61 @@
+/** Ingreso de RRHH (softdin-portal-api `AuthRrhhController`). */
+export interface UsuarioRrhh {
+    id: number;
+    nombre: string;
+    email: string;
+}
+export interface ClienteRrhh {
+    id: number;
+    nombre: string;
+    logo_url: string | null;
+}
+export interface DatosSesion {
+    usuario: UsuarioRrhh;
+    cliente: ClienteRrhh;
+    clientes: ClienteRrhh[];
+    /**
+     * Rol del usuario en el cliente de la sesión (pivote `cliente_usuario`, p. ej. `admin`) y si
+     * lo administra. Los manda `GET rrhh/me`; un servidor anterior no los manda: entonces no se sabe
+     * y lo que es solo de administradores (Auditoría) queda oculto.
+     */
+    rol?: string | null;
+    es_admin?: boolean;
+    /**
+     * Clientes internos en los que puede escribir (SSO de ámbito tenant con alcance por cliente).
+     * `null` = sin restricción; ausente = el servidor no lo dijo (versión anterior): sin restricción.
+     */
+    clientes_internos?: number[] | null;
+    /**
+     * De dónde vino la sesión: `tenant` (SSO desde softdin-tenant: solo el cliente de la sesión,
+     * sin cambio de cliente) o `central`. Ausente en servidores anteriores.
+     */
+    ambito?: 'tenant' | 'central' | null;
+}
+export interface Sesion extends DatosSesion {
+    token: string;
+}
+/** Con varios clientes y sin `cliente_id`, el servidor pide elegir (sin token). */
+export type RespuestaLogin = Sesion | {
+    requiere_cliente: true;
+    clientes: ClienteRrhh[];
+};
+export declare const authService: {
+    login(email: string, password: string, clienteId?: number): Promise<RespuestaLogin>;
+    /**
+     * Ingreso desde softdin-central (`rrhh/auth/sso`): misma respuesta que `login`. La aserción
+     * se gasta solo cuando entrega token.
+     */
+    sso(asercion: string, clienteId?: number): Promise<RespuestaLogin>;
+    me(): Promise<DatosSesion>;
+    /** Token nuevo ligado al otro cliente; el actual queda anulado. */
+    cambiarCliente(clienteId: number): Promise<Sesion>;
+    logout(): Promise<void>;
+    /** Siempre la misma respuesta, exista o no el correo. */
+    olvide(email: string): Promise<string>;
+    restablecer(datos: {
+        email: string;
+        token: string;
+        password: string;
+        password_confirmation: string;
+    }): Promise<string>;
+};

package/dist-lib/types/services/carnet.service.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Carnet digital del cliente de la sesión (softdin-portal-api, `routes/api.php`, grupo
+ * `rrhh`, `carnet/*`). Diseño en softdin-portal-api/docs/carnet-digital.md.
+ */
+/**
+ * Envío a SoftDIN de la foto aprobada (reemplaza la foto del tercero): `pendiente` = se
+ * reintenta sola; `fallida` = agotó los intentos o SoftDIN la rechazó, se reintenta a mano;
+ * null = no aplica (la foto vino de SoftDIN o ya no es la del carnet).
+ */
+export type SincronizacionFoto = 'pendiente' | 'sincronizada' | 'fallida' | null;
+export interface FotoCarnet {
+    id: number;
+    estado: 'pendiente' | 'aprobada' | 'rechazada' | 'reemplazada';
+    /** `portal` = la tomó el empleado; `softdin` = la que el tercero ya tenía en SoftDIN. */
+    origen: 'portal' | 'softdin';
+    empleado: string;
+    cargo: string | null;
+    enviada_en: string | null;
+    motivo_rechazo: string | null;
+    /** Ya tiene una foto aprobada en el carnet: esta la reemplazaría. */
+    tiene_aprobada: boolean;
+    sincronizacion: SincronizacionFoto;
+    sincronizacion_error: string | null;
+    sincronizacion_intentos: number;
+    sincronizada_en: string | null;
+}
+export interface ResultadoSincronizacion {
+    id: number;
+    estado: FotoCarnet['estado'];
+    sincronizacion: SincronizacionFoto;
+    sincronizacion_error: string | null;
+    sincronizada_en: string | null;
+}
+export interface CarnetActivo {
+    id: string;
+    empleado: string;
+    cargo: string | null;
+    emitido_en: string;
+    vence_en: string;
+}
+export declare const carnetService: {
+    config(): Promise<boolean>;
+    activar(activo: boolean): Promise<boolean>;
+    /** Con `clienteInterno`, solo las de los empleados de ese cliente interno. */
+    fotos(estado?: FotoCarnet["estado"], clienteInterno?: number | null): Promise<FotoCarnet[]>;
+    /** La imagen va con el token de la sesión: se pide como blob y se muestra con una URL local. */
+    imagen(id: number): Promise<Blob>;
+    /** Aprueba la foto y la envía a SoftDIN; responde cómo quedó ese envío. */
+    aprobar(id: number): Promise<ResultadoSincronizacion>;
+    /** Reintenta a mano el envío a SoftDIN de una foto aprobada. */
+    sincronizar(id: number): Promise<ResultadoSincronizacion>;
+    rechazar(id: number, motivo: string): Promise<void>;
+    /** Con `clienteInterno`, solo los de los empleados de ese cliente interno. */
+    carnets(clienteInterno?: number | null): Promise<CarnetActivo[]>;
+    revocar(id: string): Promise<void>;
+};

package/dist-lib/types/services/cartelera.service.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Cartelera de la app del empleado (softdin-portal-api, `routes/api.php`, grupo `rrhh`,
+ * `cartelera/*`). Desde el 2026-10-09 la administra el portal; antes se armaba en SoftDIN
+ * (Gestión portal → Cartelera) y llegaba por sincronización: esas siguen aquí con
+ * `desde_softdin`, sin el archivo original.
+ */
+export type EstadoPublicacion = 'borrador' | 'publicada' | 'retirada';
+export interface PaginaPublicacion {
+    /** Desde 1. */
+    n: number;
+    ancho: number;
+    alto: number;
+}
+export interface PublicacionCartelera {
+    id: number;
+    /** Cliente interno; null = todo el tenant. */
+    cliente_interno_id: number | null;
+    titulo: string;
+    resumen: string | null;
+    tipo_archivo: 'imagen' | 'pdf' | null;
+    archivo_nombre: string | null;
+    /** Hay archivo original para descargar (las que vinieron de SoftDIN no lo traen). */
+    tiene_original: boolean;
+    paginas: PaginaPublicacion[];
+    fecha_desde: string;
+    fecha_hasta: string | null;
+    orden: number;
+    destacada: boolean;
+    estado: EstadoPublicacion;
+    publicada_en: string | null;
+    /** Se armó en SoftDIN antes de que la cartelera pasara al portal. */
+    desde_softdin: boolean;
+    /** Marca de tiempo del último cambio: sirve para volver a pedir las imágenes. */
+    actualizada: number;
+}
+export interface PublicacionCarteleraPayload {
+    /** Cliente interno; null = todo el tenant. `undefined` en una edición = se conserva. */
+    cliente_interno_id?: number | null;
+    titulo: string;
+    resumen: string;
+    fecha_desde: string;
+    fecha_hasta: string | null;
+    orden: number;
+    destacada: boolean;
+    /** Solo si se cambia el archivo: el original y sus páginas ya convertidas. */
+    archivo?: File;
+    paginas?: Blob[];
+}
+export interface FiltroCartelera {
+    estado?: EstadoPublicacion | null;
+    cliente_interno_id?: number | null;
+}
+export declare function formularioPublicacion(p: PublicacionCarteleraPayload): FormData;
+export declare const carteleraService: {
+    listar(filtro?: FiltroCartelera): Promise<PublicacionCartelera[]>;
+    ver(id: number): Promise<PublicacionCartelera>;
+    /** Nace en borrador. */
+    crear(p: PublicacionCarteleraPayload): Promise<PublicacionCartelera>;
+    /** Multipart: PHP no lo lee en un PATCH, así que va como POST con `_method=PATCH`. Sin archivo conserva las páginas. */
+    actualizar(id: number, p: PublicacionCarteleraPayload): Promise<PublicacionCartelera>;
+    eliminar(id: number): Promise<void>;
+    /** 422 si la vigencia ya terminó o no tiene páginas. */
+    publicar(id: number): Promise<PublicacionCartelera>;
+    retirar(id: number): Promise<PublicacionCartelera>;
+    /** Imagen de una página (`n` desde 1). Va con el token de la sesión: se pide como blob. */
+    pagina(id: number, n: number): Promise<Blob>;
+    /** Archivo original tal como se subió (404 si no lo tiene). */
+    archivo(id: number): Promise<Blob>;
+};