1330 lines
57 KiB
PHP
1330 lines
57 KiB
PHP
<?php
|
|
require_once __DIR__ . '/../config/config.php';
|
|
header('Content-Type: application/json; charset=utf-8');
|
|
|
|
$pdo = obtenerConexion();
|
|
$input = json_decode(file_get_contents('php://input'), true);
|
|
$accion = $input['accion'] ?? '';
|
|
|
|
const LARGO_PIN = 4;
|
|
|
|
function obtenerUsuariosActivosPorSede($pdo, $sedeId) {
|
|
$stmt = $pdo->prepare('
|
|
SELECT u.* FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE us.sede_id = ? AND u.activo = 1 AND u.rol IN ("profesional", "administrativa")
|
|
ORDER BY u.rol ASC, u.nombre_completo ASC
|
|
');
|
|
$stmt->execute([$sedeId]);
|
|
return $stmt->fetchAll();
|
|
}
|
|
|
|
function pinValido($pin) {
|
|
return is_string($pin) && preg_match('/^\d{' . LARGO_PIN . '}$/', $pin);
|
|
}
|
|
|
|
function generarNumeroLegajo($pdo) {
|
|
$anio = date('Y');
|
|
$stmt = $pdo->prepare("SELECT COUNT(*) AS total FROM profesionales_legajos WHERE numero_legajo LIKE ?");
|
|
$stmt->execute(["LG-$anio-%"]);
|
|
$total = (int) $stmt->fetch()['total'];
|
|
return "LG-$anio-" . str_pad($total + 1, 3, '0', STR_PAD_LEFT);
|
|
}
|
|
|
|
/**
|
|
* Genera un sello automático tipo texto (nombre + título +
|
|
* matrícula) como imagen SVG en base64, similar a un sello de
|
|
* profesional escaneado pero generado al instante. Sirve como
|
|
* firma de partida; el profesional puede reemplazarla después
|
|
* dibujando o subiendo su propia firma/sello real.
|
|
*/
|
|
function generarSelloAutomatico($titulo, $nombre, $apellido, $especialidad, $matriculaNacional, $matriculaProvincial) {
|
|
// mb_strtoupper respeta tildes y caracteres UTF-8 (strtoupper
|
|
// normal corrompe letras como "ó" o "í" porque procesa byte
|
|
// por byte). Si por algún motivo mbstring no está disponible
|
|
// en el hosting, usamos el texto tal cual en vez de romper.
|
|
$aMayusculas = function_exists('mb_strtoupper')
|
|
? fn($t) => mb_strtoupper($t, 'UTF-8')
|
|
: fn($t) => strtoupper($t);
|
|
|
|
$nombreCompleto = htmlspecialchars("$titulo $nombre $apellido", ENT_QUOTES);
|
|
$tituloLimpio = trim(str_replace('.', '', $titulo));
|
|
$tituloEspecialidad = $especialidad ? $especialidad : ($tituloLimpio . (str_contains($titulo, 'Dr') ? ' MÉDICO' : ''));
|
|
$tituloEspecialidad = trim($aMayusculas($tituloEspecialidad));
|
|
$tituloEspecialidad = htmlspecialchars($tituloEspecialidad, ENT_QUOTES);
|
|
|
|
$lineaMatricula = '';
|
|
if ($matriculaNacional && $matriculaProvincial) {
|
|
$lineaMatricula = "M.N. $matriculaNacional - M.P. $matriculaProvincial";
|
|
} elseif ($matriculaNacional) {
|
|
$lineaMatricula = "M.N. $matriculaNacional";
|
|
} elseif ($matriculaProvincial) {
|
|
$lineaMatricula = "M.P. $matriculaProvincial";
|
|
}
|
|
$lineaMatricula = htmlspecialchars($lineaMatricula, ENT_QUOTES);
|
|
|
|
$alturaTotal = $lineaMatricula ? 130 : 100;
|
|
|
|
$svg = '<svg xmlns="http://www.w3.org/2000/svg" width="460" height="' . $alturaTotal . '" viewBox="0 0 460 ' . $alturaTotal . '"><!--sello-automatico-->'
|
|
. '<text x="230" y="44" text-anchor="middle" font-family="Georgia, \'Times New Roman\', serif" font-style="italic" font-size="34" fill="#1C2421">' . $nombreCompleto . '</text>'
|
|
. ($tituloEspecialidad ? '<text x="230" y="74" text-anchor="middle" font-family="Arial, sans-serif" font-size="17" letter-spacing="1" fill="#1C2421">' . $tituloEspecialidad . '</text>' : '')
|
|
. ($lineaMatricula ? '<text x="230" y="102" text-anchor="middle" font-family="Arial, sans-serif" font-size="17" letter-spacing="1" fill="#1C2421">' . $lineaMatricula . '</text>' : '')
|
|
. '</svg>';
|
|
|
|
return 'data:image/svg+xml;base64,' . base64_encode($svg);
|
|
}
|
|
|
|
function aplicarBloqueoFuerzaBruta($claveSesionIntentos, $claveSesionBloqueo) {
|
|
if (!isset($_SESSION[$claveSesionIntentos])) $_SESSION[$claveSesionIntentos] = 0;
|
|
if (!isset($_SESSION[$claveSesionBloqueo])) $_SESSION[$claveSesionBloqueo] = 0;
|
|
|
|
if (time() < $_SESSION[$claveSesionBloqueo]) {
|
|
$espera = $_SESSION[$claveSesionBloqueo] - time();
|
|
http_response_code(429);
|
|
echo json_encode(['ok' => false, 'error' => "Demasiados intentos. Esperá $espera segundos."]);
|
|
exit;
|
|
}
|
|
}
|
|
|
|
function registrarIntentoFallido($claveSesionIntentos, $claveSesionBloqueo) {
|
|
$_SESSION[$claveSesionIntentos]++;
|
|
if ($_SESSION[$claveSesionIntentos] >= 5) {
|
|
$_SESSION[$claveSesionBloqueo] = time() + 30;
|
|
$_SESSION[$claveSesionIntentos] = 0;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// ESTADO INICIAL: en qué etapa de configuración está el sistema.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'estado') {
|
|
$hayDesarrollador = $pdo->query('SELECT COUNT(*) AS t FROM desarrollador')->fetch()['t'] > 0;
|
|
if (!$hayDesarrollador) {
|
|
echo json_encode(['ok' => true, 'etapa' => 'sin_desarrollador', 'largo_pin' => LARGO_PIN]);
|
|
exit;
|
|
}
|
|
|
|
$sedesConUsuarios = $pdo->query('
|
|
SELECT COUNT(*) AS t FROM sedes s
|
|
INNER JOIN usuarios_sedes us ON us.sede_id = s.id
|
|
INNER JOIN usuarios u ON u.id = us.usuario_id AND u.activo = 1
|
|
WHERE s.activa = 1
|
|
')->fetch()['t'];
|
|
|
|
if ($sedesConUsuarios == 0) {
|
|
echo json_encode(['ok' => true, 'etapa' => 'sin_sedes_o_usuarios', 'largo_pin' => LARGO_PIN]);
|
|
exit;
|
|
}
|
|
|
|
echo json_encode(['ok' => true, 'etapa' => 'listo', 'largo_pin' => LARGO_PIN]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// LISTAR SEDES ACTIVAS (paso 1 del login normal).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_sedes_login') {
|
|
$stmt = $pdo->query('
|
|
SELECT s.id, s.nombre FROM sedes s
|
|
INNER JOIN usuarios_sedes us ON us.sede_id = s.id
|
|
INNER JOIN usuarios u ON u.id = us.usuario_id AND u.activo = 1
|
|
WHERE s.activa = 1
|
|
GROUP BY s.id
|
|
ORDER BY s.nombre ASC
|
|
');
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// LISTAR USUARIOS DE UNA SEDE (paso 2 del login normal).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_usuarios_sede_login') {
|
|
$sedeId = $input['sede_id'] ?? 0;
|
|
$usuarios = obtenerUsuariosActivosPorSede($pdo, $sedeId);
|
|
$datos = array_map(function ($u) {
|
|
return ['id' => $u['id'], 'nombre_completo' => $u['nombre_completo'], 'rol' => $u['rol']];
|
|
}, $usuarios);
|
|
echo json_encode(['ok' => true, 'datos' => $datos]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// LISTAR PROFESIONALES DE UNA SEDE (para que la administrativa
|
|
// elija a quién representa, dentro del paso 3 del login).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_profesionales_sede_login') {
|
|
$sedeId = $input['sede_id'] ?? 0;
|
|
$stmt = $pdo->prepare('
|
|
SELECT u.id, u.nombre_completo FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE u.rol = "profesional" AND u.activo = 1 AND us.sede_id = ?
|
|
ORDER BY u.nombre_completo ASC
|
|
');
|
|
$stmt->execute([$sedeId]);
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// VERIFICAR PIN (paso 3 del login normal).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'verificar') {
|
|
aplicarBloqueoFuerzaBruta('intentos_fallidos', 'bloqueado_hasta');
|
|
|
|
$sedeId = $input['sede_id'] ?? 0;
|
|
$usuarioId = $input['usuario_id'] ?? 0;
|
|
$pin = trim($input['pin'] ?? '');
|
|
$profesionalActivoId = $input['profesional_activo_id'] ?? null;
|
|
|
|
$stmt = $pdo->prepare('SELECT * FROM usuarios WHERE id = ? AND activo = 1');
|
|
$stmt->execute([$usuarioId]);
|
|
$usuario = $stmt->fetch();
|
|
|
|
if (!$usuario || !password_verify($pin . APP_SECRET, $usuario['patron_hash'])) {
|
|
registrarIntentoFallido('intentos_fallidos', 'bloqueado_hasta');
|
|
http_response_code(401);
|
|
echo json_encode(['ok' => false, 'error' => 'PIN incorrecto.']);
|
|
exit;
|
|
}
|
|
|
|
$stmtSede = $pdo->prepare('SELECT 1 FROM usuarios_sedes WHERE usuario_id = ? AND sede_id = ?');
|
|
$stmtSede->execute([$usuarioId, $sedeId]);
|
|
if (!$stmtSede->fetch()) {
|
|
http_response_code(403);
|
|
echo json_encode(['ok' => false, 'error' => 'Este usuario no pertenece a la sede elegida.']);
|
|
exit;
|
|
}
|
|
|
|
// Verificar licencia para profesionales: si venció el período
|
|
// contratado, bloqueamos el acceso y marcamos como suspendido.
|
|
if ($usuario['rol'] === 'profesional') {
|
|
$estadoLicencia = $usuario['estado_licencia'] ?? 'activo';
|
|
|
|
// Si tiene días definidos, chequear si el período venció.
|
|
if ($estadoLicencia === 'activo' && !empty($usuario['licencia_dias']) && !empty($usuario['licencia_inicio'])) {
|
|
$inicio = new DateTime($usuario['licencia_inicio']);
|
|
$vencimiento = clone $inicio;
|
|
$vencimiento->modify('+' . (int) $usuario['licencia_dias'] . ' days');
|
|
if (new DateTime() > $vencimiento) {
|
|
$estadoLicencia = 'suspendido';
|
|
$pdo->prepare('UPDATE usuarios SET estado_licencia = "suspendido" WHERE id = ?')->execute([$usuarioId]);
|
|
}
|
|
}
|
|
|
|
if ($estadoLicencia !== 'activo') {
|
|
$mensajes = [
|
|
'suspendido' => 'Tu licencia de acceso venció. Comunicarte con el administrador del sistema para renovarla.',
|
|
'pausado' => 'Tu cuenta está pausada temporalmente. Comunicarte con el administrador del sistema.',
|
|
'prohibido' => 'Tu cuenta está inhabilitada. Comunicarte con el administrador del sistema.',
|
|
];
|
|
http_response_code(403);
|
|
echo json_encode(['ok' => false, 'error' => $mensajes[$estadoLicencia] ?? 'No podés acceder al sistema en este momento.']);
|
|
exit;
|
|
}
|
|
}
|
|
|
|
$_SESSION['autenticado'] = true;
|
|
$_SESSION['usuario_id'] = $usuario['id'];
|
|
$_SESSION['nombre_usuario'] = $usuario['nombre_completo'];
|
|
$_SESSION['rol'] = $usuario['rol'];
|
|
$_SESSION['sede_id'] = (int) $sedeId;
|
|
$_SESSION['intentos_fallidos'] = 0;
|
|
|
|
$nombreParaMostrar = $usuario['nombre_completo'];
|
|
|
|
if ($usuario['rol'] === 'administrativa') {
|
|
if (!$profesionalActivoId) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Falta indicar a qué profesional representa esta administrativa.']);
|
|
exit;
|
|
}
|
|
$stmtProf = $pdo->prepare('
|
|
SELECT u.nombre_completo FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE u.id = ? AND u.rol = "profesional" AND u.activo = 1 AND us.sede_id = ?
|
|
');
|
|
$stmtProf->execute([$profesionalActivoId, $sedeId]);
|
|
$profesionalRepresentado = $stmtProf->fetch();
|
|
if (!$profesionalRepresentado) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El profesional elegido no pertenece a esta sede.']);
|
|
exit;
|
|
}
|
|
$_SESSION['profesional_activo_id'] = (int) $profesionalActivoId;
|
|
// En pantalla se muestra el nombre del profesional, nunca el
|
|
// de la administrativa, para que no se "mezclen" las cuentas
|
|
// visualmente. Internamente (auditoría, etc.) se sigue
|
|
// registrando que fue la administrativa quien actuó.
|
|
$nombreParaMostrar = $profesionalRepresentado['nombre_completo'];
|
|
}
|
|
|
|
echo json_encode([
|
|
'ok' => true,
|
|
'nombre_usuario' => $nombreParaMostrar,
|
|
'rol' => $usuario['rol'],
|
|
]);
|
|
exit;
|
|
}
|
|
|
|
// ============================================================
|
|
// DESARROLLADOR
|
|
// ============================================================
|
|
|
|
if ($accion === 'crear_desarrollador') {
|
|
$hay = $pdo->query('SELECT COUNT(*) AS t FROM desarrollador')->fetch()['t'];
|
|
if ($hay > 0) {
|
|
http_response_code(409);
|
|
echo json_encode(['ok' => false, 'error' => 'Ya existe una clave de desarrollador configurada.']);
|
|
exit;
|
|
}
|
|
$clave = trim($input['clave'] ?? '');
|
|
if (!pinValido($clave)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'La clave debe tener exactamente ' . LARGO_PIN . ' números.']);
|
|
exit;
|
|
}
|
|
$hash = password_hash($clave . APP_SECRET, PASSWORD_BCRYPT);
|
|
$pdo->prepare('INSERT INTO desarrollador (clave_hash) VALUES (?)')->execute([$hash]);
|
|
|
|
$_SESSION['autenticado'] = true;
|
|
$_SESSION['usuario_id'] = null;
|
|
$_SESSION['nombre_usuario'] = 'Desarrollador';
|
|
$_SESSION['rol'] = 'desarrollador';
|
|
|
|
echo json_encode(['ok' => true, 'rol' => 'desarrollador', 'nombre_usuario' => 'Desarrollador']);
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'verificar_desarrollador') {
|
|
aplicarBloqueoFuerzaBruta('dev_intentos_fallidos', 'dev_bloqueado_hasta');
|
|
|
|
$clave = trim($input['clave'] ?? '');
|
|
$fila = $pdo->query('SELECT * FROM desarrollador ORDER BY id ASC LIMIT 1')->fetch();
|
|
|
|
if (!$fila || !password_verify($clave . APP_SECRET, $fila['clave_hash'])) {
|
|
registrarIntentoFallido('dev_intentos_fallidos', 'dev_bloqueado_hasta');
|
|
http_response_code(401);
|
|
echo json_encode(['ok' => false, 'error' => 'Clave incorrecta.']);
|
|
exit;
|
|
}
|
|
|
|
$_SESSION['autenticado'] = true;
|
|
$_SESSION['usuario_id'] = null;
|
|
$_SESSION['nombre_usuario'] = 'Desarrollador';
|
|
$_SESSION['rol'] = 'desarrollador';
|
|
$_SESSION['dev_intentos_fallidos'] = 0;
|
|
|
|
echo json_encode(['ok' => true, 'rol' => 'desarrollador', 'nombre_usuario' => 'Desarrollador']);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// GESTIÓN DE SEDES (solo desarrollador)
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'crear_sede') {
|
|
requiereDesarrollador();
|
|
$nombre = trim($input['nombre'] ?? '');
|
|
if ($nombre === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ingresá el nombre de la sede.']);
|
|
exit;
|
|
}
|
|
|
|
// Si ya existe una sede con ese nombre pero está desactivada,
|
|
// la reactivamos en vez de fallar por el nombre duplicado.
|
|
$stmtExistente = $pdo->prepare('SELECT id, activa FROM sedes WHERE nombre = ?');
|
|
$stmtExistente->execute([$nombre]);
|
|
$existente = $stmtExistente->fetch();
|
|
|
|
if ($existente && $existente['activa']) {
|
|
http_response_code(409);
|
|
echo json_encode(['ok' => false, 'error' => 'Ya existe una sede activa con ese nombre.']);
|
|
exit;
|
|
}
|
|
|
|
if ($existente && !$existente['activa']) {
|
|
$pdo->prepare('UPDATE sedes SET activa = 1 WHERE id = ?')->execute([$existente['id']]);
|
|
registrarAuditoria($pdo, 'crear', 'sede', $existente['id'], "Se reactivó la sede \"$nombre\".");
|
|
echo json_encode(['ok' => true, 'id' => $existente['id']]);
|
|
exit;
|
|
}
|
|
|
|
$pdo->prepare('INSERT INTO sedes (nombre) VALUES (?)')->execute([$nombre]);
|
|
registrarAuditoria($pdo, 'crear', 'sede', $pdo->lastInsertId(), "Se creó la sede \"$nombre\".");
|
|
echo json_encode(['ok' => true, 'id' => $pdo->lastInsertId()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// RENOMBRAR SEDE — solo desarrollador. Como pacientes y
|
|
// profesionales se vinculan por sede_id (no por el nombre como
|
|
// texto copiado), cambiar el nombre aquí actualiza automática-
|
|
// mente cómo se ve en todos lados, sin tocar ni perder ningún
|
|
// legajo existente.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'renombrar_sede') {
|
|
requiereDesarrollador();
|
|
$id = $input['id'] ?? 0;
|
|
$nombreNuevo = trim($input['nombre'] ?? '');
|
|
|
|
if ($nombreNuevo === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ingresá el nuevo nombre de la sede.']);
|
|
exit;
|
|
}
|
|
|
|
$stmt = $pdo->prepare('SELECT nombre FROM sedes WHERE id = ?');
|
|
$stmt->execute([$id]);
|
|
$sedeActual = $stmt->fetch();
|
|
if (!$sedeActual) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Esa sede no existe.']);
|
|
exit;
|
|
}
|
|
|
|
$stmtDuplicado = $pdo->prepare('SELECT id FROM sedes WHERE nombre = ? AND activa = 1 AND id != ?');
|
|
$stmtDuplicado->execute([$nombreNuevo, $id]);
|
|
if ($stmtDuplicado->fetch()) {
|
|
http_response_code(409);
|
|
echo json_encode(['ok' => false, 'error' => 'Ya existe otra sede activa con ese nombre.']);
|
|
exit;
|
|
}
|
|
|
|
$pdo->prepare('UPDATE sedes SET nombre = ? WHERE id = ?')->execute([$nombreNuevo, $id]);
|
|
registrarAuditoria($pdo, 'editar', 'sede', $id, "Se renombró la sede de \"{$sedeActual['nombre']}\" a \"$nombreNuevo\".");
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'listar_sedes') {
|
|
requiereDesarrollador();
|
|
$stmt = $pdo->query('SELECT * FROM sedes WHERE activa = 1 ORDER BY nombre ASC');
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'desactivar_sede') {
|
|
requiereDesarrollador();
|
|
$id = $input['id'] ?? 0;
|
|
$pdo->prepare('UPDATE sedes SET activa = 0 WHERE id = ?')->execute([$id]);
|
|
registrarAuditoria($pdo, 'desactivar', 'sede', $id, 'Se desactivó una sede.');
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// PAPELERA (DESARROLLADOR): listar profesionales de una sede,
|
|
// para elegir de quién ver la papelera y a quién reasignar.
|
|
// (Reutiliza la misma idea que listar_profesionales_sede_login,
|
|
// pero accesible solo para el Desarrollador.)
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_profesionales_sede_dev') {
|
|
requiereDesarrollador();
|
|
$sedeId = $input['sede_id'] ?? 0;
|
|
$stmt = $pdo->prepare('
|
|
SELECT u.id, u.nombre_completo FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE u.rol = "profesional" AND u.activo = 1 AND us.sede_id = ?
|
|
ORDER BY u.nombre_completo ASC
|
|
');
|
|
$stmt->execute([$sedeId]);
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// PAPELERA (DESARROLLADOR): ver los legajos eliminados de un
|
|
// profesional específico (GET vía POST con accion en el body,
|
|
// igual que el resto de este archivo).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_papelera_dev') {
|
|
requiereDesarrollador();
|
|
$profesionalId = $input['profesional_id'] ?? 0;
|
|
$sedeId = $input['sede_id'] ?? 0;
|
|
$stmt = $pdo->prepare('
|
|
SELECT id, paciente_id_original, nombre_completo, dni, eliminado_en, sede_id_original
|
|
FROM legajos_eliminados
|
|
WHERE profesional_id_original = ? AND sede_id_original = ?
|
|
ORDER BY eliminado_en DESC
|
|
');
|
|
$stmt->execute([$profesionalId, $sedeId]);
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// PAPELERA (DESARROLLADOR): recuperar un legajo eliminado,
|
|
// asignándolo a un profesional de la MISMA sede donde estaba
|
|
// originalmente (no se permite recuperar hacia otra sede, para
|
|
// evitar que un paciente "viaje" de sede sin que el Desarrollador
|
|
// lo haga a propósito desde la ficha del paciente ya recuperado).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'recuperar_legajo_dev') {
|
|
requiereDesarrollador();
|
|
$idPapelera = $input['id'] ?? 0;
|
|
$nuevoProfesionalId = $input['profesional_id'] ?? 0;
|
|
|
|
$stmt = $pdo->prepare('SELECT * FROM legajos_eliminados WHERE id = ?');
|
|
$stmt->execute([$idPapelera]);
|
|
$registro = $stmt->fetch();
|
|
if (!$registro) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese registro de la papelera no existe.']);
|
|
exit;
|
|
}
|
|
|
|
$sedeOriginalId = $registro['sede_id_original'];
|
|
|
|
// Confirmar que el nuevo profesional realmente atienda en esa misma sede.
|
|
$stmtCheck = $pdo->prepare('
|
|
SELECT u.nombre_completo FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE u.id = ? AND u.rol = "profesional" AND u.activo = 1 AND us.sede_id = ?
|
|
');
|
|
$stmtCheck->execute([$nuevoProfesionalId, $sedeOriginalId]);
|
|
$nuevoProfesional = $stmtCheck->fetch();
|
|
if (!$nuevoProfesional) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese profesional no atiende en la sede donde estaba este legajo.']);
|
|
exit;
|
|
}
|
|
|
|
$datos = json_decode($registro['datos_json'], true);
|
|
$sesionesGuardadas = $datos['sesiones'] ?? [];
|
|
unset($datos['sesiones'], $datos['edad']); // no son columnas de la tabla pacientes
|
|
|
|
// Si el legajo se está asignando a un profesional DISTINTO del
|
|
// que lo tenía antes de eliminarlo, guardamos el nombre del
|
|
// profesional original para que quede visible en la ficha.
|
|
$nombreProfesionalAnterior = null;
|
|
$profesionalOriginalId = $registro['profesional_id_original'];
|
|
if ($profesionalOriginalId && (int) $profesionalOriginalId !== (int) $nuevoProfesionalId) {
|
|
$stmtAnterior = $pdo->prepare('SELECT nombre_completo FROM usuarios WHERE id = ?');
|
|
$stmtAnterior->execute([$profesionalOriginalId]);
|
|
$filaAnterior = $stmtAnterior->fetch();
|
|
if ($filaAnterior) {
|
|
$nombreProfesionalAnterior = $filaAnterior['nombre_completo'];
|
|
}
|
|
}
|
|
|
|
$pdo->beginTransaction();
|
|
try {
|
|
$stmt = $pdo->prepare('
|
|
INSERT INTO pacientes
|
|
(profesional_id, sede_id, recuperado_de_profesional, nombre, apellido, dni, fecha_nacimiento, sexo, obra_social_id, numero_afiliado,
|
|
telefono, email, direccion, motivo_consulta, patologia, sintomas, observaciones_generales)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
');
|
|
$stmt->execute([
|
|
$nuevoProfesionalId,
|
|
$sedeOriginalId,
|
|
$nombreProfesionalAnterior,
|
|
$datos['nombre'] ?? '',
|
|
$datos['apellido'] ?? '',
|
|
$datos['dni'] ?? '',
|
|
$datos['fecha_nacimiento'] ?? null,
|
|
$datos['sexo'] ?? 'Otro',
|
|
$datos['obra_social_id'] ?? null,
|
|
$datos['numero_afiliado'] ?? null,
|
|
$datos['telefono'] ?? null,
|
|
$datos['email'] ?? null,
|
|
$datos['direccion'] ?? null,
|
|
$datos['motivo_consulta'] ?? null,
|
|
$datos['patologia'] ?? null,
|
|
$datos['sintomas'] ?? null,
|
|
$datos['observaciones_generales'] ?? null,
|
|
]);
|
|
$nuevoPacienteId = $pdo->lastInsertId();
|
|
|
|
if (!empty($sesionesGuardadas) && is_array($sesionesGuardadas)) {
|
|
$stmtSesion = $pdo->prepare('INSERT INTO sesiones (paciente_id, fecha_sesion, descripcion, evolucion, proxima_cita) VALUES (?, ?, ?, ?, ?)');
|
|
foreach ($sesionesGuardadas as $s) {
|
|
$stmtSesion->execute([
|
|
$nuevoPacienteId,
|
|
$s['fecha_sesion'] ?? date('Y-m-d'),
|
|
$s['descripcion'] ?? '',
|
|
$s['evolucion'] ?? null,
|
|
$s['proxima_cita'] ?? null,
|
|
]);
|
|
}
|
|
}
|
|
|
|
$pdo->prepare('DELETE FROM legajos_eliminados WHERE id = ?')->execute([$idPapelera]);
|
|
|
|
$pdo->commit();
|
|
registrarAuditoria(
|
|
$pdo, 'crear', 'paciente', $nuevoPacienteId,
|
|
"Se recuperó de la papelera el legajo de {$datos['nombre']} {$datos['apellido']}, asignado a {$nuevoProfesional['nombre_completo']}."
|
|
);
|
|
echo json_encode(['ok' => true, 'id' => $nuevoPacienteId]);
|
|
} catch (Exception $e) {
|
|
$pdo->rollBack();
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo recuperar el legajo.']);
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// BUSCAR PROFESIONALES (DESARROLLADOR) — búsqueda unificada
|
|
// por nombre, apellido, DNI o número de legajo.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'buscar_profesionales') {
|
|
requiereDesarrollador();
|
|
$q = trim($input['q'] ?? '');
|
|
if ($q === '') {
|
|
echo json_encode(['ok' => true, 'datos' => []]);
|
|
exit;
|
|
}
|
|
$like = "%$q%";
|
|
$stmt = $pdo->prepare("
|
|
SELECT u.id, u.nombre_completo, u.activo, u.estado_licencia, u.creado_en,
|
|
u.licencia_dias, u.licencia_inicio,
|
|
CASE WHEN u.licencia_dias IS NULL THEN NULL
|
|
ELSE DATE_ADD(u.licencia_inicio, INTERVAL u.licencia_dias DAY)
|
|
END AS licencia_vencimiento,
|
|
pl.numero_legajo, pl.titulo, pl.especialidad, pl.dni
|
|
FROM usuarios u
|
|
INNER JOIN profesionales_legajos pl ON pl.usuario_id = u.id
|
|
WHERE u.rol = 'profesional'
|
|
AND (
|
|
u.nombre_completo LIKE ?
|
|
OR pl.nombre LIKE ?
|
|
OR pl.apellido LIKE ?
|
|
OR pl.dni LIKE ?
|
|
OR pl.numero_legajo LIKE ?
|
|
)
|
|
ORDER BY pl.apellido ASC, pl.nombre ASC
|
|
LIMIT 30
|
|
");
|
|
$stmt->execute([$like, $like, $like, $like, $like]);
|
|
$resultados = $stmt->fetchAll();
|
|
|
|
$stmtSedes = $pdo->prepare('SELECT s.id, s.nombre FROM sedes s INNER JOIN usuarios_sedes us ON us.sede_id = s.id WHERE us.usuario_id = ?');
|
|
foreach ($resultados as &$r) {
|
|
$stmtSedes->execute([$r['id']]);
|
|
$r['sedes'] = $stmtSedes->fetchAll();
|
|
}
|
|
|
|
echo json_encode(['ok' => true, 'datos' => $resultados]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// PROFESIONALES DESACTIVADOS (DESARROLLADOR): listar usuarios
|
|
// con rol profesional que ya no tienen acceso (activo = 0), para
|
|
// poder ver y reasignar los legajos que les quedaron a cargo.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_profesionales_desactivados') {
|
|
requiereDesarrollador();
|
|
$stmt = $pdo->query("
|
|
SELECT u.id, u.nombre_completo,
|
|
(SELECT COUNT(*) FROM pacientes p WHERE p.profesional_id = u.id) AS total_pacientes
|
|
FROM usuarios u
|
|
WHERE u.rol = 'profesional' AND u.activo = 0
|
|
HAVING total_pacientes > 0
|
|
ORDER BY u.nombre_completo ASC
|
|
");
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// LEGAJOS ACTIVOS DE UN PROFESIONAL DESACTIVADO (DESARROLLADOR)
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_legajos_huerfanos') {
|
|
requiereDesarrollador();
|
|
$profesionalId = $input['profesional_id'] ?? 0;
|
|
$stmt = $pdo->prepare('
|
|
SELECT p.id, p.nombre, p.apellido, p.dni, p.sede_id, s.nombre AS sede_nombre
|
|
FROM pacientes p
|
|
LEFT JOIN sedes s ON s.id = p.sede_id
|
|
WHERE p.profesional_id = ?
|
|
ORDER BY p.apellido ASC, p.nombre ASC
|
|
');
|
|
$stmt->execute([$profesionalId]);
|
|
echo json_encode(['ok' => true, 'datos' => $stmt->fetchAll()]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// REASIGNAR LEGAJO HUÉRFANO (DESARROLLADOR): transfiere un
|
|
// paciente activo a otro profesional de la MISMA sede donde
|
|
// está el paciente (misma regla que la papelera: no se permite
|
|
// cambiar de sede de paso, solo de profesional).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'reasignar_legajo_huerfano') {
|
|
requiereDesarrollador();
|
|
$pacienteId = $input['paciente_id'] ?? 0;
|
|
$nuevoProfesionalId = $input['profesional_id'] ?? 0;
|
|
|
|
$stmtPaciente = $pdo->prepare('SELECT * FROM pacientes WHERE id = ?');
|
|
$stmtPaciente->execute([$pacienteId]);
|
|
$paciente = $stmtPaciente->fetch();
|
|
if (!$paciente) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese paciente no existe.']);
|
|
exit;
|
|
}
|
|
|
|
$stmtCheck = $pdo->prepare('
|
|
SELECT u.nombre_completo FROM usuarios u
|
|
INNER JOIN usuarios_sedes us ON us.usuario_id = u.id
|
|
WHERE u.id = ? AND u.rol = "profesional" AND u.activo = 1 AND us.sede_id = ?
|
|
');
|
|
$stmtCheck->execute([$nuevoProfesionalId, $paciente['sede_id']]);
|
|
$nuevoProfesional = $stmtCheck->fetch();
|
|
if (!$nuevoProfesional) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese profesional no atiende en la sede de este paciente.']);
|
|
exit;
|
|
}
|
|
|
|
// Si el profesional anterior queda registrado, lo guardamos
|
|
// como "recuperado_de_profesional" igual que en la papelera,
|
|
// para que quede el mismo aviso en la ficha del paciente.
|
|
$nombreProfesionalAnterior = null;
|
|
if ($paciente['profesional_id'] && (int) $paciente['profesional_id'] !== (int) $nuevoProfesionalId) {
|
|
$stmtAnterior = $pdo->prepare('SELECT nombre_completo FROM usuarios WHERE id = ?');
|
|
$stmtAnterior->execute([$paciente['profesional_id']]);
|
|
$filaAnterior = $stmtAnterior->fetch();
|
|
if ($filaAnterior) $nombreProfesionalAnterior = $filaAnterior['nombre_completo'];
|
|
}
|
|
|
|
try {
|
|
$pdo->prepare('UPDATE pacientes SET profesional_id = ?, recuperado_de_profesional = ? WHERE id = ?')
|
|
->execute([$nuevoProfesionalId, $nombreProfesionalAnterior, $pacienteId]);
|
|
|
|
registrarAuditoria(
|
|
$pdo, 'editar', 'paciente', $pacienteId,
|
|
"Se transfirió el legajo de {$paciente['nombre']} {$paciente['apellido']} a {$nuevoProfesional['nombre_completo']} (profesional anterior desactivado)."
|
|
);
|
|
echo json_encode(['ok' => true]);
|
|
} catch (PDOException $e) {
|
|
if ($e->getCode() === '23000') {
|
|
http_response_code(409);
|
|
echo json_encode(['ok' => false, 'error' => 'El profesional elegido ya tiene un paciente con ese mismo DNI.']);
|
|
} else {
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo transferir el legajo.']);
|
|
}
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// CONFIGURACIÓN INICIAL: crea la primera sede y el primer
|
|
// profesional en un solo paso, justo después de crear la
|
|
// clave de Desarrollador.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'crear_setup_inicial') {
|
|
requiereDesarrollador();
|
|
$nombreSede = trim($input['nombre_sede'] ?? '');
|
|
$nombreProfesional = trim($input['nombre_profesional'] ?? '');
|
|
$pin = trim($input['pin'] ?? '');
|
|
|
|
if ($nombreSede === '' || $nombreProfesional === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Completá el nombre de la sede y del profesional.']);
|
|
exit;
|
|
}
|
|
if (!pinValido($pin)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El PIN debe tener exactamente ' . LARGO_PIN . ' números.']);
|
|
exit;
|
|
}
|
|
|
|
$pdo->beginTransaction();
|
|
try {
|
|
$pdo->prepare('INSERT INTO sedes (nombre) VALUES (?)')->execute([$nombreSede]);
|
|
$sedeId = $pdo->lastInsertId();
|
|
|
|
$hash = password_hash($pin . APP_SECRET, PASSWORD_BCRYPT);
|
|
$pdo->prepare('INSERT INTO usuarios (nombre_completo, rol, patron_hash) VALUES (?, "profesional", ?)')
|
|
->execute([$nombreProfesional, $hash]);
|
|
$usuarioId = $pdo->lastInsertId();
|
|
|
|
$pdo->prepare('INSERT INTO usuarios_sedes (usuario_id, sede_id) VALUES (?, ?)')->execute([$usuarioId, $sedeId]);
|
|
|
|
$pdo->commit();
|
|
registrarAuditoria($pdo, 'crear', 'sede', $sedeId, "Configuración inicial: sede \"$nombreSede\" y profesional \"$nombreProfesional\".");
|
|
echo json_encode(['ok' => true, 'sede_id' => $sedeId, 'usuario_id' => $usuarioId]);
|
|
} catch (PDOException $e) {
|
|
$pdo->rollBack();
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo completar la configuración inicial.']);
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// CREAR USUARIO (profesional o administrativa) — solo desarrollador
|
|
// ------------------------------------------------------------
|
|
// ------------------------------------------------------------
|
|
// CREAR PROFESIONAL (legajo completo) — solo desarrollador.
|
|
// Reemplaza el alta simple anterior: ahora incluye datos
|
|
// personales, especialidad, sede(s), PIN y tipo de licencia.
|
|
// Para administrativas se mantiene el alta simple de antes.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'crear_usuario') {
|
|
requiereDesarrollador();
|
|
$rol = $input['rol'] ?? '';
|
|
$pin = trim($input['pin'] ?? '');
|
|
$sedeIds = $input['sede_ids'] ?? [];
|
|
|
|
if (!in_array($rol, ['profesional', 'administrativa'])) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Rol no válido.']);
|
|
exit;
|
|
}
|
|
if (!pinValido($pin)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El PIN debe tener exactamente ' . LARGO_PIN . ' números.']);
|
|
exit;
|
|
}
|
|
if (empty($sedeIds) || !is_array($sedeIds)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Elegí al menos una sede.']);
|
|
exit;
|
|
}
|
|
|
|
if ($rol === 'profesional') {
|
|
$titulo = $input['titulo'] ?? 'Dr.';
|
|
$nombre = trim($input['nombre'] ?? '');
|
|
$apellido = trim($input['apellido'] ?? '');
|
|
$dni = trim($input['dni'] ?? '') ?: null;
|
|
$fechaNac = $input['fecha_nacimiento'] ?? null ?: null;
|
|
$lugarNac = trim($input['lugar_nacimiento'] ?? '') ?: null;
|
|
$especialidad = trim($input['especialidad'] ?? '') ?: null;
|
|
$matriculaNacional = trim($input['matricula_nacional'] ?? '') ?: null;
|
|
$matriculaProvincial = trim($input['matricula_provincial'] ?? '') ?: null;
|
|
$email = trim($input['email'] ?? '') ?: null;
|
|
$telefono = trim($input['telefono'] ?? '') ?: null;
|
|
$licenciaDias = $input['licencia_dias'] !== '' ? (int) $input['licencia_dias'] : null;
|
|
|
|
if ($nombre === '' || $apellido === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ingresá el nombre y apellido del profesional.']);
|
|
exit;
|
|
}
|
|
|
|
$titulos = ['Dr.', 'Dra.', 'Lic.', 'Tec.', 'Mg.', 'Prof.', 'Otro'];
|
|
if (!in_array($titulo, $titulos)) $titulo = 'Dr.';
|
|
|
|
$nombreCompleto = "$titulo $nombre $apellido";
|
|
$hash = password_hash($pin . APP_SECRET, PASSWORD_BCRYPT);
|
|
$selloAutomatico = generarSelloAutomatico($titulo, $nombre, $apellido, $especialidad, $matriculaNacional, $matriculaProvincial);
|
|
|
|
$pdo->beginTransaction();
|
|
try {
|
|
$stmt = $pdo->prepare('INSERT INTO usuarios (nombre_completo, rol, patron_hash, estado_licencia, licencia_dias, licencia_inicio) VALUES (?, "profesional", ?, "activo", ?, CURDATE())');
|
|
$stmt->execute([$nombreCompleto, $hash, $licenciaDias]);
|
|
$nuevoId = $pdo->lastInsertId();
|
|
|
|
$numeroLegajo = generarNumeroLegajo($pdo);
|
|
$stmtLegajo = $pdo->prepare('
|
|
INSERT INTO profesionales_legajos
|
|
(usuario_id, numero_legajo, titulo, nombre, apellido, dni, fecha_nacimiento, lugar_nacimiento, especialidad, matricula_nacional, matricula_provincial, email, telefono, firma_digital)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
');
|
|
$stmtLegajo->execute([$nuevoId, $numeroLegajo, $titulo, $nombre, $apellido, $dni, $fechaNac, $lugarNac, $especialidad, $matriculaNacional, $matriculaProvincial, $email, $telefono, $selloAutomatico]);
|
|
|
|
$stmtSede = $pdo->prepare('INSERT INTO usuarios_sedes (usuario_id, sede_id) VALUES (?, ?)');
|
|
foreach ($sedeIds as $sid) $stmtSede->execute([$nuevoId, $sid]);
|
|
|
|
$pdo->commit();
|
|
registrarAuditoria($pdo, 'crear', 'usuario', $nuevoId, "Se creó el legajo del profesional \"$nombreCompleto\".");
|
|
echo json_encode(['ok' => true, 'id' => $nuevoId]);
|
|
} catch (PDOException $e) {
|
|
$pdo->rollBack();
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo crear el legajo.']);
|
|
}
|
|
} else {
|
|
// Administrativa: alta simple como antes
|
|
$nombre = trim($input['nombre_completo'] ?? '');
|
|
if ($nombre === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ingresá el nombre de la administrativa.']);
|
|
exit;
|
|
}
|
|
$hash = password_hash($pin . APP_SECRET, PASSWORD_BCRYPT);
|
|
$pdo->beginTransaction();
|
|
try {
|
|
$stmt = $pdo->prepare('INSERT INTO usuarios (nombre_completo, rol, patron_hash) VALUES (?, "administrativa", ?)');
|
|
$stmt->execute([$nombre, $hash]);
|
|
$nuevoId = $pdo->lastInsertId();
|
|
$stmtSede = $pdo->prepare('INSERT INTO usuarios_sedes (usuario_id, sede_id) VALUES (?, ?)');
|
|
foreach ($sedeIds as $sid) $stmtSede->execute([$nuevoId, $sid]);
|
|
$pdo->commit();
|
|
registrarAuditoria($pdo, 'crear', 'usuario', $nuevoId, "Se creó la administrativa \"$nombre\".");
|
|
echo json_encode(['ok' => true, 'id' => $nuevoId]);
|
|
} catch (PDOException $e) {
|
|
$pdo->rollBack();
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo crear la administrativa.']);
|
|
}
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// OBTENER LEGAJO DE UN PROFESIONAL — Desarrollador y el propio
|
|
// profesional pueden consultar.
|
|
// ------------------------------------------------------------
|
|
// ------------------------------------------------------------
|
|
// EDITAR LEGAJO DE PROFESIONAL — solo desarrollador. Actualiza
|
|
// los datos personales y mantiene sincronizado el nombre que
|
|
// se muestra en el login (nombre_completo de usuarios).
|
|
// ------------------------------------------------------------
|
|
// ------------------------------------------------------------
|
|
// GUARDAR FIRMA DIGITAL — el propio profesional sube o dibuja
|
|
// su firma (PNG en base64), que se inserta automáticamente al
|
|
// pie de cada PDF que exporte de sus pacientes.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'guardar_firma_digital') {
|
|
requiereSesion();
|
|
if (($_SESSION['rol'] ?? '') !== 'profesional') {
|
|
http_response_code(403);
|
|
echo json_encode(['ok' => false, 'error' => 'Solo un profesional puede guardar su propia firma.']);
|
|
exit;
|
|
}
|
|
$usuarioId = (int) $_SESSION['usuario_id'];
|
|
$firmaBase64 = $input['firma'] ?? '';
|
|
|
|
if ($firmaBase64 === '') {
|
|
// Permite borrar la firma actual mandando un valor vacío.
|
|
$pdo->prepare('UPDATE profesionales_legajos SET firma_digital = NULL WHERE usuario_id = ?')->execute([$usuarioId]);
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
if (!preg_match('/^data:image\/(png|jpeg|jpg);base64,([A-Za-z0-9+\/=]+)$/', $firmaBase64, $coincidencia)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El archivo tiene que ser una imagen PNG o JPEG válida.']);
|
|
exit;
|
|
}
|
|
|
|
// Límite de ~2MB en base64 (≈1.5MB de imagen real), de sobra
|
|
// para una firma y evita que alguien guarde algo gigante.
|
|
if (strlen($firmaBase64) > 2 * 1024 * 1024) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'La imagen de la firma es demasiado grande.']);
|
|
exit;
|
|
}
|
|
|
|
$pdo->prepare('UPDATE profesionales_legajos SET firma_digital = ? WHERE usuario_id = ?')->execute([$firmaBase64, $usuarioId]);
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $usuarioId, 'Actualizó su firma digital.');
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'editar_legajo_profesional') {
|
|
requiereDesarrollador();
|
|
$usuarioId = (int) ($input['usuario_id'] ?? 0);
|
|
$titulo = $input['titulo'] ?? 'Dr.';
|
|
$nombre = trim($input['nombre'] ?? '');
|
|
$apellido = trim($input['apellido'] ?? '');
|
|
$dni = trim($input['dni'] ?? '') ?: null;
|
|
$fechaNac = $input['fecha_nacimiento'] ?? null ?: null;
|
|
$lugarNac = trim($input['lugar_nacimiento'] ?? '') ?: null;
|
|
$especialidad = trim($input['especialidad'] ?? '') ?: null;
|
|
$matriculaNacional = trim($input['matricula_nacional'] ?? '') ?: null;
|
|
$matriculaProvincial = trim($input['matricula_provincial'] ?? '') ?: null;
|
|
$email = trim($input['email'] ?? '') ?: null;
|
|
$telefono = trim($input['telefono'] ?? '') ?: null;
|
|
|
|
if ($nombre === '' || $apellido === '') {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Ingresá el nombre y apellido del profesional.']);
|
|
exit;
|
|
}
|
|
|
|
$titulos = ['Dr.', 'Dra.', 'Lic.', 'Tec.', 'Mg.', 'Prof.', 'Otro'];
|
|
if (!in_array($titulo, $titulos)) $titulo = 'Dr.';
|
|
|
|
$stmtCheck = $pdo->prepare('SELECT id, firma_digital FROM profesionales_legajos WHERE usuario_id = ?');
|
|
$stmtCheck->execute([$usuarioId]);
|
|
$legajoActual = $stmtCheck->fetch();
|
|
if (!$legajoActual) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese legajo no existe.']);
|
|
exit;
|
|
}
|
|
|
|
// Solo regeneramos el sello automático si la firma actual es
|
|
// VACÍA o sigue siendo el sello automático (no si el profesional
|
|
// ya cargó su propia firma manual/escaneada, para no pisarla).
|
|
// El sello automático siempre es un SVG (las firmas dibujadas o
|
|
// subidas son PNG/JPEG), así que primero confirmamos que sea un
|
|
// SVG antes de decodificarlo y buscar la marca interna.
|
|
$firmaActual = $legajoActual['firma_digital'] ?? '';
|
|
$esSvg = is_string($firmaActual) && str_starts_with($firmaActual, 'data:image/svg+xml;base64,');
|
|
$esSelloAutomaticoOVacio = $firmaActual === '' || $firmaActual === null
|
|
|| ($esSvg && str_contains(base64_decode(substr($firmaActual, strlen('data:image/svg+xml;base64,'))) ?: '', 'sello-automatico'));
|
|
|
|
$pdo->beginTransaction();
|
|
try {
|
|
if ($esSelloAutomaticoOVacio) {
|
|
$selloNuevo = generarSelloAutomatico($titulo, $nombre, $apellido, $especialidad, $matriculaNacional, $matriculaProvincial);
|
|
$stmt = $pdo->prepare('
|
|
UPDATE profesionales_legajos
|
|
SET titulo = ?, nombre = ?, apellido = ?, dni = ?, fecha_nacimiento = ?,
|
|
lugar_nacimiento = ?, especialidad = ?, matricula_nacional = ?, matricula_provincial = ?,
|
|
email = ?, telefono = ?, firma_digital = ?
|
|
WHERE usuario_id = ?
|
|
');
|
|
$stmt->execute([$titulo, $nombre, $apellido, $dni, $fechaNac, $lugarNac, $especialidad, $matriculaNacional, $matriculaProvincial, $email, $telefono, $selloNuevo, $usuarioId]);
|
|
} else {
|
|
$stmt = $pdo->prepare('
|
|
UPDATE profesionales_legajos
|
|
SET titulo = ?, nombre = ?, apellido = ?, dni = ?, fecha_nacimiento = ?,
|
|
lugar_nacimiento = ?, especialidad = ?, matricula_nacional = ?, matricula_provincial = ?,
|
|
email = ?, telefono = ?
|
|
WHERE usuario_id = ?
|
|
');
|
|
$stmt->execute([$titulo, $nombre, $apellido, $dni, $fechaNac, $lugarNac, $especialidad, $matriculaNacional, $matriculaProvincial, $email, $telefono, $usuarioId]);
|
|
}
|
|
|
|
$nombreCompleto = "$titulo $nombre $apellido";
|
|
$pdo->prepare('UPDATE usuarios SET nombre_completo = ? WHERE id = ?')->execute([$nombreCompleto, $usuarioId]);
|
|
|
|
$pdo->commit();
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $usuarioId, "Se editó el legajo de \"$nombreCompleto\".");
|
|
echo json_encode(['ok' => true]);
|
|
} catch (PDOException $e) {
|
|
$pdo->rollBack();
|
|
if ($e->getCode() === '23000') {
|
|
http_response_code(409);
|
|
echo json_encode(['ok' => false, 'error' => 'Ya existe un profesional con ese DNI.']);
|
|
} else {
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo guardar el legajo.']);
|
|
}
|
|
}
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'obtener_legajo_profesional') {
|
|
requiereSesion();
|
|
$rol = $_SESSION['rol'] ?? '';
|
|
$usuarioId = (int) ($input['usuario_id'] ?? 0);
|
|
|
|
// El profesional solo puede ver su propio legajo.
|
|
if ($rol === 'profesional') {
|
|
$usuarioId = (int) $_SESSION['usuario_id'];
|
|
} elseif ($rol !== 'desarrollador') {
|
|
http_response_code(403);
|
|
echo json_encode(['ok' => false, 'error' => 'Sin permiso.']);
|
|
exit;
|
|
}
|
|
|
|
$stmt = $pdo->prepare('
|
|
SELECT pl.*, u.estado_licencia, u.licencia_dias, u.licencia_inicio, u.activo,
|
|
CASE
|
|
WHEN u.licencia_dias IS NULL THEN NULL
|
|
ELSE DATE_ADD(u.licencia_inicio, INTERVAL u.licencia_dias DAY)
|
|
END AS licencia_vencimiento
|
|
FROM profesionales_legajos pl
|
|
INNER JOIN usuarios u ON u.id = pl.usuario_id
|
|
WHERE pl.usuario_id = ?
|
|
');
|
|
$stmt->execute([$usuarioId]);
|
|
$legajo = $stmt->fetch();
|
|
if (!$legajo) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Legajo no encontrado.']);
|
|
exit;
|
|
}
|
|
echo json_encode(['ok' => true, 'datos' => $legajo]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// ACTUALIZAR LICENCIA — solo desarrollador.
|
|
// Permite activar (con duración), pausar, prohibir el acceso.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'actualizar_licencia') {
|
|
requiereDesarrollador();
|
|
$usuarioId = $input['usuario_id'] ?? 0;
|
|
$nuevoEstado = $input['estado'] ?? '';
|
|
$diasLicencia = isset($input['dias']) && $input['dias'] !== '' ? (int) $input['dias'] : null;
|
|
|
|
$estadosValidos = ['activo', 'pausado', 'prohibido'];
|
|
if (!in_array($nuevoEstado, $estadosValidos)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Estado no válido.']);
|
|
exit;
|
|
}
|
|
|
|
$licenciaInicio = $nuevoEstado === 'activo' ? date('Y-m-d') : null;
|
|
$pdo->prepare('UPDATE usuarios SET estado_licencia = ?, licencia_dias = ?, licencia_inicio = ? WHERE id = ?')
|
|
->execute([$nuevoEstado, $nuevoEstado === 'activo' ? $diasLicencia : null, $licenciaInicio, $usuarioId]);
|
|
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $usuarioId, "Se cambió el estado de licencia a \"$nuevoEstado\"" . ($licenciaInicio && $diasLicencia ? " por $diasLicencia días." : "."));
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// LISTAR USUARIOS (con sus sedes) — solo desarrollador.
|
|
// Solo se muestran los activos: los desactivados quedan
|
|
// fuera de este listado (pero siguen existiendo en la base,
|
|
// así que el historial de cambios sigue siendo legible).
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'listar_usuarios') {
|
|
requiereDesarrollador();
|
|
$stmt = $pdo->query("
|
|
SELECT u.id, u.nombre_completo, u.rol, u.activo, u.creado_en,
|
|
u.estado_licencia, u.licencia_dias, u.licencia_inicio,
|
|
CASE
|
|
WHEN u.licencia_dias IS NULL THEN NULL
|
|
ELSE DATE_ADD(u.licencia_inicio, INTERVAL u.licencia_dias DAY)
|
|
END AS licencia_vencimiento,
|
|
pl.titulo, pl.especialidad
|
|
FROM usuarios u
|
|
LEFT JOIN profesionales_legajos pl ON pl.usuario_id = u.id
|
|
WHERE u.activo = 1
|
|
ORDER BY u.creado_en ASC
|
|
");
|
|
$usuarios = $stmt->fetchAll();
|
|
|
|
$stmtSedes = $pdo->prepare('SELECT s.id, s.nombre FROM sedes s INNER JOIN usuarios_sedes us ON us.sede_id = s.id WHERE us.usuario_id = ?');
|
|
foreach ($usuarios as &$u) {
|
|
$stmtSedes->execute([$u['id']]);
|
|
$u['sedes'] = $stmtSedes->fetchAll();
|
|
}
|
|
|
|
echo json_encode(['ok' => true, 'datos' => $usuarios]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// DESACTIVAR USUARIO — solo desarrollador
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'desactivar_usuario') {
|
|
requiereDesarrollador();
|
|
$idDesactivar = $input['id'] ?? 0;
|
|
$pdo->prepare('UPDATE usuarios SET activo = 0 WHERE id = ?')->execute([$idDesactivar]);
|
|
registrarAuditoria($pdo, 'desactivar', 'usuario', $idDesactivar, 'Se desactivó el acceso de un usuario.');
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// REACTIVAR USUARIO — solo desarrollador. Le devuelve el
|
|
// acceso a alguien al que se le había quitado con "Quitar
|
|
// acceso". No toca licencia ni sedes, esas se gestionan aparte.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'reactivar_usuario') {
|
|
requiereDesarrollador();
|
|
$idReactivar = $input['id'] ?? 0;
|
|
$stmt = $pdo->prepare('SELECT nombre_completo FROM usuarios WHERE id = ?');
|
|
$stmt->execute([$idReactivar]);
|
|
$fila = $stmt->fetch();
|
|
if (!$fila) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese usuario no existe.']);
|
|
exit;
|
|
}
|
|
$pdo->prepare('UPDATE usuarios SET activo = 1 WHERE id = ?')->execute([$idReactivar]);
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $idReactivar, "Se restauró el acceso de \"{$fila['nombre_completo']}\".");
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// CAMBIAR PIN — solo desarrollador. Reasigna el PIN de acceso
|
|
// de un usuario, sin tener que desactivarlo y crearlo de nuevo.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'cambiar_pin_usuario') {
|
|
requiereDesarrollador();
|
|
$usuarioId = $input['usuario_id'] ?? 0;
|
|
$pin = trim($input['pin'] ?? '');
|
|
|
|
if (!pinValido($pin)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El PIN debe tener exactamente ' . LARGO_PIN . ' números.']);
|
|
exit;
|
|
}
|
|
|
|
$stmt = $pdo->prepare('SELECT nombre_completo FROM usuarios WHERE id = ?');
|
|
$stmt->execute([$usuarioId]);
|
|
$fila = $stmt->fetch();
|
|
if (!$fila) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Ese usuario no existe.']);
|
|
exit;
|
|
}
|
|
|
|
$hash = password_hash($pin . APP_SECRET, PASSWORD_BCRYPT);
|
|
$pdo->prepare('UPDATE usuarios SET patron_hash = ? WHERE id = ?')->execute([$hash, $usuarioId]);
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $usuarioId, "Se cambió el PIN de acceso de \"{$fila['nombre_completo']}\".");
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// PREVISUALIZAR CAMBIO DE SEDES — solo desarrollador.
|
|
// Antes de aplicar el cambio real, le dice al Desarrollador
|
|
// cuántos legajos se van a borrar definitivamente por cada
|
|
// sede que se le esté quitando al usuario.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'previsualizar_cambio_sedes') {
|
|
requiereDesarrollador();
|
|
$usuarioId = $input['usuario_id'] ?? 0;
|
|
$sedeIdsNuevas = $input['sede_ids'] ?? [];
|
|
|
|
$stmtActuales = $pdo->prepare('SELECT sede_id FROM usuarios_sedes WHERE usuario_id = ?');
|
|
$stmtActuales->execute([$usuarioId]);
|
|
$sedeIdsActuales = array_column($stmtActuales->fetchAll(), 'sede_id');
|
|
|
|
$sedeIdsQueSeQuitan = array_diff($sedeIdsActuales, $sedeIdsNuevas);
|
|
|
|
$detalle = [];
|
|
$totalPacientesABorrar = 0;
|
|
if (!empty($sedeIdsQueSeQuitan)) {
|
|
$stmtSede = $pdo->prepare('SELECT nombre FROM sedes WHERE id = ?');
|
|
$stmtConteo = $pdo->prepare('SELECT COUNT(*) AS t FROM pacientes WHERE profesional_id = ? AND sede_id = ?');
|
|
foreach ($sedeIdsQueSeQuitan as $sedeId) {
|
|
$stmtSede->execute([$sedeId]);
|
|
$nombreSede = $stmtSede->fetch()['nombre'] ?? 'Sede desconocida';
|
|
$stmtConteo->execute([$usuarioId, $sedeId]);
|
|
$cantidad = (int) $stmtConteo->fetch()['t'];
|
|
$totalPacientesABorrar += $cantidad;
|
|
$detalle[] = ['sede_id' => (int) $sedeId, 'nombre' => $nombreSede, 'pacientes' => $cantidad];
|
|
}
|
|
}
|
|
|
|
echo json_encode(['ok' => true, 'sedes_que_se_quitan' => $detalle, 'total_pacientes_a_borrar' => $totalPacientesABorrar]);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// ACTUALIZAR SEDES DE UN USUARIO — solo desarrollador.
|
|
// Aplica el nuevo conjunto de sedes. Si se le quita una sede
|
|
// donde el usuario es profesional y tenía pacientes, esos
|
|
// legajos (con sus sesiones, citas y adjuntos) se eliminan
|
|
// definitivamente, sin pasar por la papelera.
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'actualizar_sedes_usuario') {
|
|
requiereDesarrollador();
|
|
$usuarioId = $input['usuario_id'] ?? 0;
|
|
$sedeIdsNuevas = $input['sede_ids'] ?? [];
|
|
|
|
if (empty($sedeIdsNuevas) || !is_array($sedeIdsNuevas)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Elegí al menos una sede para esta persona.']);
|
|
exit;
|
|
}
|
|
|
|
$stmtUsuario = $pdo->prepare('SELECT nombre_completo, rol FROM usuarios WHERE id = ?');
|
|
$stmtUsuario->execute([$usuarioId]);
|
|
$usuario = $stmtUsuario->fetch();
|
|
if (!$usuario) {
|
|
http_response_code(404);
|
|
echo json_encode(['ok' => false, 'error' => 'Usuario no encontrado.']);
|
|
exit;
|
|
}
|
|
|
|
$stmtActuales = $pdo->prepare('SELECT sede_id FROM usuarios_sedes WHERE usuario_id = ?');
|
|
$stmtActuales->execute([$usuarioId]);
|
|
$sedeIdsActuales = array_column($stmtActuales->fetchAll(), 'sede_id');
|
|
$sedeIdsQueSeQuitan = array_diff($sedeIdsActuales, $sedeIdsNuevas);
|
|
|
|
$pdo->beginTransaction();
|
|
try {
|
|
// Si es profesional, borrar definitivamente sus legajos
|
|
// de cada sede que se le esté quitando.
|
|
$pacientesBorrados = 0;
|
|
if ($usuario['rol'] === 'profesional' && !empty($sedeIdsQueSeQuitan)) {
|
|
$stmtPacientesSede = $pdo->prepare('SELECT id FROM pacientes WHERE profesional_id = ? AND sede_id = ?');
|
|
$stmtBorrarPaciente = $pdo->prepare('DELETE FROM pacientes WHERE id = ?');
|
|
foreach ($sedeIdsQueSeQuitan as $sedeId) {
|
|
$stmtPacientesSede->execute([$usuarioId, $sedeId]);
|
|
$pacientesDeEstaSede = $stmtPacientesSede->fetchAll();
|
|
foreach ($pacientesDeEstaSede as $p) {
|
|
// Las sesiones, citas y adjuntos de cada paciente se
|
|
// borran en cascada por las claves foráneas (ON DELETE CASCADE).
|
|
$stmtBorrarPaciente->execute([$p['id']]);
|
|
$pacientesBorrados++;
|
|
}
|
|
}
|
|
}
|
|
|
|
$pdo->prepare('DELETE FROM usuarios_sedes WHERE usuario_id = ?')->execute([$usuarioId]);
|
|
$stmtInsertSede = $pdo->prepare('INSERT INTO usuarios_sedes (usuario_id, sede_id) VALUES (?, ?)');
|
|
foreach ($sedeIdsNuevas as $sedeId) {
|
|
$stmtInsertSede->execute([$usuarioId, $sedeId]);
|
|
}
|
|
|
|
$pdo->commit();
|
|
|
|
$descripcion = "Se actualizaron las sedes de \"{$usuario['nombre_completo']}\".";
|
|
if ($pacientesBorrados > 0) {
|
|
$descripcion .= " Se eliminaron $pacientesBorrados legajo(s) de forma definitiva por quitarle acceso a su sede.";
|
|
}
|
|
registrarAuditoria($pdo, 'editar', 'usuario', $usuarioId, $descripcion);
|
|
|
|
echo json_encode(['ok' => true, 'pacientes_borrados' => $pacientesBorrados]);
|
|
} catch (PDOException $e) {
|
|
$pdo->rollBack();
|
|
http_response_code(500);
|
|
echo json_encode(['ok' => false, 'error' => 'No se pudo actualizar las sedes del usuario.']);
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// CAMBIAR MI PROPIO PIN (cualquier usuario logueado, incluido
|
|
// el desarrollador)
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'cambiar') {
|
|
requiereSesion();
|
|
$pinNuevo = trim($input['pin_nuevo'] ?? '');
|
|
if (!pinValido($pinNuevo)) {
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'El PIN debe tener exactamente ' . LARGO_PIN . ' números.']);
|
|
exit;
|
|
}
|
|
$hash = password_hash($pinNuevo . APP_SECRET, PASSWORD_BCRYPT);
|
|
if (esDesarrollador()) {
|
|
$pdo->prepare('UPDATE desarrollador SET clave_hash = ?')->execute([$hash]);
|
|
} else {
|
|
$pdo->prepare('UPDATE usuarios SET patron_hash = ? WHERE id = ?')->execute([$hash, $_SESSION['usuario_id']]);
|
|
}
|
|
echo json_encode(['ok' => true, 'mensaje' => 'PIN actualizado.']);
|
|
exit;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// QUIÉN SOY
|
|
// ------------------------------------------------------------
|
|
if ($accion === 'quien_soy') {
|
|
requiereSesion();
|
|
$nombreParaMostrar = $_SESSION['nombre_usuario'] ?? '';
|
|
if (($_SESSION['rol'] ?? '') === 'administrativa' && !empty($_SESSION['profesional_activo_id'])) {
|
|
$stmt = $pdo->prepare('SELECT nombre_completo FROM usuarios WHERE id = ?');
|
|
$stmt->execute([$_SESSION['profesional_activo_id']]);
|
|
$fila = $stmt->fetch();
|
|
if ($fila) $nombreParaMostrar = $fila['nombre_completo'];
|
|
}
|
|
echo json_encode([
|
|
'ok' => true,
|
|
'nombre_usuario' => $nombreParaMostrar,
|
|
'rol' => $_SESSION['rol'] ?? '',
|
|
]);
|
|
exit;
|
|
}
|
|
|
|
if ($accion === 'cerrar_sesion') {
|
|
$_SESSION = [];
|
|
session_destroy();
|
|
echo json_encode(['ok' => true]);
|
|
exit;
|
|
}
|
|
|
|
http_response_code(400);
|
|
echo json_encode(['ok' => false, 'error' => 'Acción no reconocida.']);
|