Bloques 2, 3 y 4: qué explicar, qué mostrar y qué permite cada pantalla

2.1Ficha del bloque

Pregunta que responde

¿Cómo se guarda cada cambio sin perder nada y sin que dos personas se pisen, usando una hoja de cálculo como base de datos?

Archivos del servidor

BaseDatos.js 328Versionado.js 305Bloqueos.js 142Recuperacion.js 122Migraciones.js 90

Archivos del navegador

Edicion.html 186Pestanas.html 161

Lo usa

Planes.js y Fusiones.js (bloque 4), FuenteDrive.js (bloque 3), CargaDocente.js (bloque 5), GrillaEdicion.html y AsignacionEdicion.html, que crean su sesión de edición con crearSesionEdicion.

Depende de

Respuesta.js (fallo_ y los códigos), Config.js (minutosBloqueo), Dominio.REF y Dominio.isoPeru.

Pruebas

AppScript/pruebas/infraestructura.test.mjs (versionado común, bloqueos con referencia, escrituras y recuperación) y, en servidor.test.mjs, las pruebas del bloqueo por carrera, la caducidad y el latido, el conflicto, la restauración y el plan repartido en varias celdas.

Idea central

Nada se sobrescribe: cada guardado añade una versión. Dos mecanismos distintos evitan los choques: el candado del script (milisegundos) y el bloqueo de edición (minutos).

2.2Guion de exposición · unos 12 minutos

1. 0:00 – 1:00

   El problema

   «Varias personas editan los mismos planes desde su navegador y no tenemos un servidor de base de datos: tenemos una hoja de cálculo de Google. Este bloque resuelve tres riesgos: que un guardado borre otro, que dos personas editen lo mismo a la vez y que se pierda lo que no se guardó si se cierra la pestaña.»

   Muestra: el tablero con la columna «Editando» (captura 2.6).

2. 1:00 – 3:00

   La hoja como base de datos

   «BaseDatos.js define ocho pestañas en TABLAS_, cada una con sus columnas. Todo se guarda como texto plano, con formato @, porque Sheets convertiría “2026-1” en una fecha. Un texto que empieza por igual, más, menos o arroba se escribe con un apóstrofo para que nunca se ejecute como fórmula. Se lee con leerTabla_, que devuelve cada fila como un objeto y recuerda su número de fila, y se escribe en bloque con escribirFilas_, en una sola llamada.»

   Muestra: la pestaña Planes (captura 2.1) y BaseDatos.js:4 (TABLAS_).

3. 3:00 – 5:30

   Versiones: índice más historial

   «Cada documento, sea un plan o una carga docente, usa dos pestañas. El índice tiene una fila por documento con su versión vigente y la fila exacta donde está guardada. La tabla de versiones tiene una fila por guardado con el contenido completo en JSON. registrarVersion_ añade la versión y actualiza el índice. Como el contenido de una versión nunca cambia, se guarda seis horas en la caché. Restaurar no borra nada: crea una versión nueva con el contenido viejo.»

   Muestra: el historial (captura 2.9), la v3 creada al restaurar (2.10) y la pestaña Versiones (2.11).

4. 5:30 – 8:00

   El bloqueo de edición

   «Cuando alguien pulsa Editar, el servidor anota en la pestaña Bloqueos que ese plan es suyo hasta una hora de caducidad: treinta minutos después de la última actividad. Mientras haga clic o escriba, el navegador manda un latido, como mucho una vez por minuto, que mueve esa hora. Otra cuenta ve el plan bloqueado y solo puede consultarlo. Si nadie hace nada en treinta minutos, el navegador guarda lo pendiente como versión y suelta el plan.»

   Muestra: dos pestañas con cuentas distintas (capturas 2.4 a 2.8) y la expiración (2.21).

5. 8:00 – 9:30

   Conflicto de versiones: advertir, no prohibir

   «El bloqueo no cubre todos los casos: la misma persona puede tener el plan abierto en dos pestañas, o el Excel puede actualizarse mientras se edita. Por eso cada guardado envía la versión sobre la que se trabajó. Si en el servidor ya hay una más nueva, responde CONFLICTO y el navegador pregunta. Si la persona insiste, se guarda con forzar, y la otra versión sigue en el historial.»

   Muestra: capturas 2.14 a 2.16.

6. 9:30 – 10:45

   Copia de recuperación

   «Cada minuto, si hay cambios sin guardar, el navegador manda una copia a la pestaña Recuperacion. No es una versión: es una sola fila por persona y documento. Si la página se cae, al volver a editar se ofrece recuperarla. Se escribe con un candado breve de dos segundos: si el sistema está ocupado con un guardado de verdad, la copia se salta y se repite al minuto siguiente.»

   Muestra: la pestaña Recuperacion (2.17) y el diálogo (2.18).

7. 10:45 – 11:30

   Avisos entre pestañas

   «Las pestañas del mismo navegador se avisan con BroadcastChannel cuando alguien toma o suelta un plan, guarda una versión o relee los Excel. Así el tablero se actualiza sin pedirlo al servidor. Es solo una comodidad: la fuente de verdad sigue siendo el servidor, y sin el canal todo funciona igual.»

   Muestra: captura 2.13 o 2.15.

8. 11:30 – 12:00

   Migraciones y cierre

   «instalar() se puede repetir sin riesgo: crea las pestañas que falten y aplica dos migraciones que solo tocan lo que aún está en el formato viejo: las fechas pasan a hora de Perú y las cargas por departamento pasan a cargas por carrera. Resumen: versiones que nunca se borran, un candado para las escrituras, un bloqueo para las personas y una copia por si algo falla.»

2.3Conceptos clave

Las ocho pestañas de «SISCargaLectiva-BD»

Reglas de escritura en la hoja

Dos niveles de exclusión

Índice y versiones: cómo se lee la vigente sin recorrer la tabla

Ciclo de vida de un bloqueo

Línea de tiempo de una sesión de edición

Qué se guarda en la caché del script y cuánto

2.4Recorrido con capturas

Usa dos pestañas: una con ?usuario=mfloresl@ulasalle.edu.pe (cuenta A) y otra con ?usuario=fmaresg@ulasalle.edu.pe (cuenta B).

1. Tomar el bloqueo de un plan

   con la cuenta A, en el tablero, pulsa Editar en Ingeniería de Software.

   

   Verás

   La grilla se abre al instante con el contenido que trajo el tablero. En cuanto llega la respuesta, el reloj empieza a contar 30:00 hacia atrás.

   En el código

   abrirEdicion (GrillaEdicion.html:107) pinta la grilla y llama de fondo a abrirEdicion del servidor (Planes.js:200), que dentro de conCandado_ ejecuta tomarBloqueo_ y devuelve expira y la copia de recuperación si existe. confirmarEdicion arranca la sesión con sesionPlan.iniciar(expira).

   Detalle fino

   Si el navegador ya tenía la versión vigente, el servidor no vuelve a mandar el contenido (versionConocida). Si entretanto se guardó otra versión y aún no hay cambios, se carga esa y aparece «Se cargó la versión más reciente del plan».

2. La reserva en la pestaña Bloqueos

   mira la pestaña Bloqueos mientras la cuenta A edita.

   

   En el código

   tomarBloqueo_ (Bloqueos.js:71) reescribe la fila si ya existía para esa referencia, o añade una. Si el bloqueo vigente es de otra cuenta devuelve ok: false. «desde» se conserva en las renovaciones; «expira» siempre se mueve.

3. La otra cuenta ve el plan bloqueado

   con la cuenta B, abre Registrar plan de ciclo.

   

   En el código

   leerTablero_ (Planes.js:122) añade a cada fila su bloqueo vigente. pintarTablero (Tablero.html:187) muestra «Bloqueado» solo si el bloqueo es de otra cuenta.

4. Intentar editar un plan bloqueado

   con la cuenta B, pulsa Editar en ING.

   

   

   En el código

   Como el tablero ya sabe que otra cuenta lo tiene, abrirEdicion no abre la grilla: llama a abrirEdicionEsperando, que espera la respuesta. falloBloqueado_ (Bloqueos.js:60) arma el error y avisarBloqueado (GrillaEdicion.html:197) ofrece consultar.

5. Guardar crea una versión

   con la cuenta A, haz un cambio y pulsa Guardar cambios; luego abre Historial de versiones.

   

   En el código

   obtenerHistorial (Planes.js:266) devuelve metaVersiones_ sin el contenido ni la fila. dialogoHistorial (Edicion.html:166) es común al plan y a la carga.

6. Restaurar no borra el historial

   elige v1 y pulsa Restaurar.

   

   

   En el código

   restaurarVersion (Planes.js:281) lee la versión pedida, la pasa por prepararFusiones_ y la registra con Dominio.TIPO_VERSION.restauracion(k). El estado nunca baja de Registrado (resolverEstado_).

7. Salir de la edición suelta el plan

   pulsa Salir de la edición y confirma.

   

   

   En el código

   terminarEdicion (GrillaEdicion.html:67) descarta la copia de recuperación, avisa a las otras pestañas con anunciar("soltado") y llama a liberarBloqueo. Si se cierra la pestaña, el evento pagehide llama a liberarBloqueo sin esperar respuesta.

8. La misma cuenta en dos pestañas

   con la cuenta A editando Derecho, abre otra pestaña con la misma cuenta y pulsa Editar en Derecho.

   

   En el código

   otraPestanaEditando y avisarOtraPestana (Pestanas.html:69 y :75). La lista de planes en edición se llena con los mensajes «editando», y una pestaña nueva la pide con «hola».

9. Conflicto de versiones

   elige «Editar aquí de todos modos», guarda en la segunda pestaña y después guarda en la primera.

   

   

   En el código

   El navegador manda versionBase. conflictoPlan_ (Planes.js:109) compara con la vigente; guardar (GrillaEdicion.html:223) captura el código y llama a confirmarConflicto (Edicion.html:150).

10. Copia de recuperación

    edita un plan sin guardar y cierra la pestaña de golpe (o espera a que pase un minuto). Vuelve a pulsar Editar en ese plan.

    

    

    

    En el código

    La sesión llama a copia() cada 60 s y solo envía si el contenido cambió desde la última copia que el servidor confirmó. guardarRecuperacion (Recuperacion.js:88) usa conCandadoSiLibre_ con 2 s: si está ocupado responde {omitida: true} y se repite al minuto. abrirEdicion devuelve la copia con leerRecuperacion_.

    Para la demo

    En la captura, la copia se creó llamando a guardarRecuperacion desde la vista previa, que es lo mismo que hace el navegador cada minuto.

11. Bloqueo perdido

    deja pasar el tiempo de bloqueo sin actividad mientras otra cuenta toma el plan; luego haz clic en la grilla.

    

    En el código

    renovarBloqueo_ (Bloqueos.js:89) falla si tomarBloqueo_ devuelve ok: false. En el navegador, latido (Edicion.html:61) reconoce el código y llama a op.alPerder, que en el plan es bloqueoPerdido (GrillaEdicion.html:24).

    Para la demo

    Para no esperar, en la captura se cambió el correo de la fila de Bloqueos por el de la cuenta B, que es lo que hace tomarBloqueo_ cuando otra cuenta toma un bloqueo caducado.

12. La sesión expira y se autoguarda

    haz un cambio y no toques nada hasta que el reloj llegue a cero.

    

    En el código

    expirar (GrillaEdicion.html:35) llama a guardarPlan con tipo: "autoguardado" y forzar: true, y luego a liberarBloqueo. Si no había cambios solo suelta el plan.

2.5Catálogo de acciones y posibilidades

2.6Código clave comentado

Escribir texto seguro y escribir en bloque

function celdaTexto_(v) {
  const t = v == null ? "" : String(v);
  return /^[=+\-@]/.test(t) ? "'" + t : t;   // nunca una fórmula
}

function escribirFilas_(nombre, fila, filas) {
  if (!filas.length) return;
  const h = hojaBd_(nombre);
  const ancho = filas.reduce(function (n, f) { return Math.max(n, f.length); }, 0);
  asegurarTamano_(h, fila + filas.length - 1, ancho);   // filas y columnas nuevas, en formato texto
  h.getRange(fila, 1, filas.length, ancho).setValues(filas.map(function (f) {
    const v = f.map(celdaTexto_);
    while (v.length < ancho) v.push("");
    return v;
  }));                                                   // una sola llamada a Sheets
}

El candado del script

function conCandado_(fn) {
  const candado = LockService.getScriptLock();
  if (!candado.tryLock(30000))
    fallo_("OCUPADO", "El sistema está ocupado con otra operación. Inténtalo de nuevo en unos segundos.");
  try {
    return fn();
  } finally {
    SpreadsheetApp.flush();      // escribe todo antes de soltar
    candado.releaseLock();
  }
}

Registrar una versión

function registrarVersion_(repo, ciclo, clave, fila, datos) {
  const n = vigente_(fila).version + 1;                       // la siguiente versión
  const texto = JSON.stringify(datos.contenido);
  const comunes = { ciclo: ciclo, n: n, usuario: datos.usuario, fecha: datos.fecha };
  comunes[repo.clave] = clave;
  const meta = Object.assign({}, datos.meta || {}, comunes);
  const camposVersion = TABLAS_[repo.versiones].slice(0, columnaContenido_(repo));
  const filaVersion = agregarFila_(repo.versiones,             // 1. fila nueva en Versiones
    camposVersion.map(function (c) { return meta[c] == null ? "" : meta[c]; }).concat(trocear_(texto)));

  const indice = Object.assign({}, fila || {}, datos.indice || {}, {
    ciclo: ciclo, version: n, actualizado_por: datos.usuario, actualizado_en: datos.fecha, fila_version: filaVersion
  });
  indice[repo.clave] = clave;
  const valores = TABLAS_[repo.indice].map(function (c) { return indice[c] == null ? "" : indice[c]; });
  if (fila) escribirFila_(repo.indice, fila._fila, valores);   // 2. índice: reescribe
  else agregarFila_(repo.indice, valores);                   //    o añade si es el primer guardado

  cachearTexto_(claveContenido_(repo, ciclo, clave, n), texto); // 3. caché del contenido
  /* …y completa en la caché la lista de versiones, si estaba */
  return n;
}

Tomar o renovar un bloqueo

function tomarBloqueo_(ciclo, ref, correo) {
  const b = leerBloqueos_().filter(function (x) { return x.ciclo === ciclo && x.ref === ref; })[0];
  if (bloqueoVigente_(b) && b.correo !== correo) return { ok: false, bloqueo: b };  // es de otra cuenta
  const desde = bloqueoVigente_(b) ? b.desde : Dominio.isoPeru();                  // se conserva al renovar
  const expira = Dominio.isoPeru(Date.now() + config_().minutosBloqueo * 60000);
  const valores = [ciclo, ref, correo, desde, expira];
  if (b) escribirFila_(TABLA_.BLOQUEOS, b._fila, valores);   // reutiliza la fila de esa ref
  else agregarFila_(TABLA_.BLOQUEOS, valores);
  return { ok: true, desde: desde, expira: expira };
}

El latido en el navegador

async function latido(){
  if (!s.temporizador) return;                                   // no hay sesión activa
  const intervalo = Math.min(60000, CONFIG.minutosBloqueo * 15000);
  if (Date.now() - s.ultimoLatido < intervalo) return;            // como mucho uno por intervalo
  s.ultimoLatido = Date.now();
  const generacion = s.generacion;
  let r;
  try {
    r = await op.renovar();
  } catch (e) {
    if (generacion !== s.generacion || !s.temporizador) return;  // respuesta de una sesión anterior
    if (e && e.codigo === "BLOQUEO_PERDIDO") { detener(); return op.alPerder(e.detalle ? e.detalle.correo : ""); }
    return;   // un fallo de red: la siguiente actividad lo reintenta
  }
  if (generacion !== s.generacion || !s.temporizador) return;
  s.expira = Date.parse(r.expira);
  pintar();
  if (op.alRenovar) op.alRenovar();
}
["click", "keydown"].forEach(ev => document.addEventListener(ev, latido, { passive: true }));

Guardar con conflicto

async function guardar(datos){
  const p = app.plan, sig = app.carrera;
  const base = { asignaturas: p.asignaturas, versionBase: p.version, fusionesDisueltas: p.fusionesDisueltas || [] };
  let r;
  try {
    r = await llamar("guardarPlan", app.ciclo, sig, Object.assign({}, base, datos));
  } catch (e) {
    if (e.codigo !== "CONFLICTO") throw e;
    if (!await confirmarConflicto(e.detalle, "del plan")) return null;   // advertir…
    r = await llamar("guardarPlan", app.ciclo, sig, Object.assign({}, base, datos, { forzar: true }));  // …no prohibir
  }
  Object.assign(p, { version: r.version, estado: r.estado, sucio: false, fusionesDisueltas: [] });
  sesionPlan.olvidarCopia();
  sesionPlan.renovada(r.expira);
  anunciarGuardado(sig, r.estado, r.version, p.asignaturas);           // avisa a las otras pestañas
  /* … */
}

La copia de recuperación con candado breve

const guardada = conCandadoSiLibre_(function () {
  const f = filaRecuperacion_(c, r.ref, usuario.correo);
  const fecha = Dominio.isoPeru();
  const valores = [c, r.ref, usuario.correo, fecha, String(parseInt(String(datos && datos.versionBase), 10) || 0)].concat(trocear_(texto));
  if (f) { /* limpia las celdas sobrantes y reescribe su fila */ }
  else agregarFila_(TABLA_.RECUPERACION, valores);
  return { fecha: fecha };
}, MS_CANDADO_RECUPERACION_);                 // 2000 ms
return guardada || { fecha: null, omitida: true };

Mensajes entre pestañas

2.7Errores, avisos y casos límite

2.8Preguntas probables

2.9Para practicar

• Abre la vista previa con dos cuentas distintas, edita ING con una y comprueba con la otra que aparece «Bloqueado» y que solo puede consultar.
• Abre dos pestañas con la misma cuenta, guarda en una y luego en la otra hasta ver el diálogo de conflicto.
• Guarda dos veces un plan, abre el historial, restaura la v1 y explica por qué aparece una v4 y no se borra nada.
• Lee registrarVersion_ y di en voz alta qué celdas escribe y en qué orden.
• Ejecuta las pruebas de infraestructura y explica qué comprueba cada una.

node --test AppScript/pruebas/infraestructura.test.mjs AppScript/pruebas/servidor.test.mjs

3.1Ficha del bloque

Pregunta que responde

¿Cómo una tabla (un Excel de Drive, un rango pegado o un archivo subido) se convierte en asignaturas, grupos y asignaciones, sin rechazar nunca lo que llega?

Archivos del servidor

LectorXlsx.js 310OfertaXlsx.js 90FuenteDrive.js 217CargaDocenteCatalogo.js 95

Archivos del navegador

Rejilla.html 148ImportarOferta.html 184AsignacionCarga.html 191

Parte de Dominio.js

L116–240 normalización y textoL465–611 deducir columnas e interpretarL1357–1516 hoja de CargaXDepartamento

Lo usa

El bloque 4 recibe las asignaturas interpretadas en la grilla. El bloque 2 guarda las versiones de importación. El bloque 5 recibe las asignaciones de la carga masiva y el catálogo de docentes.

Pruebas

AppScript/pruebas/lector.test.mjs: los Excel reales dan la misma oferta que el prototipo, 8 carreras, 345 asignaturas y 365 grupos.

Idea central

El sistema interpreta y no valida: lo que se entiende entra, lo que no se entiende se conserva como texto, y solo se toman las filas de la carrera del plan (CU-001 v4.0).

3.2Guion de exposición · unos 12 minutos

1. 0:00 – 1:00

   El principio: interpretar, nunca rechazar

   «Hoy la oferta vive en varios Excel que cada carrera llena a su manera. Si el sistema rechazara un archivo por una columna mal escrita, nadie lo usaría. Por eso el caso de uso dice que la carga nunca se rechaza: se interpreta lo que llega, el texto que no se entiende se guarda tal cual y el coordinador lo corrige después en la grilla.»

2. 1:00 – 2:00

   Tres puertas de entrada

   «Los datos entran por tres caminos: los Excel de la carpeta de Drive, que el sistema lee solo; la carga masiva de la oferta, donde el coordinador pega un rango o sube un archivo; y la carga masiva de asignaciones, donde el director pega la hoja de su departamento.»

   Muestra: el diagrama de las tres entradas (más abajo).

3. 2:00 – 4:00

   Los Excel de Drive

   «En la carpeta del sistema hay tres tipos de archivo y se reconocen por el nombre: CargaXCarrera, CargaXDepartamento y CargaDeDocentes. Si hay varios del mismo tipo se usa el más reciente, y si alguien lo convirtió a Hoja de Google se avisa y no se lee. El sistema nunca los modifica. Como mirar la carpeta cuesta decenas de llamadas a Drive, se mira como mucho cada cinco minutos; el botón Releer Excel lo fuerza.»

   Muestra: «Releer Excel» (captura 3.2) y los avisos de la carpeta (3.4).

4. 4:00 – 5:30

   Saber si algo cambió

   «Cada archivo tiene una firma: tipo, id de Drive y fecha de modificación, que se guarda en la pestaña Fuentes. Si la firma es igual, no se lee nada. Si cambió, se lee el Excel fuera del candado, porque tarda, y después, dentro del candado, se compara plan por plan con un hash de su contenido. Solo los planes cuyo contenido cambió reciben una versión: “importación desde xlsx” si es la primera, “actualización desde xlsx” si ya tenía.»

   Muestra: la pestaña Fuentes (3.3) y aplicarOferta_ (FuenteDrive.js:181).

5. 5:30 – 7:00

   Leer un .xlsx sin convertirlo

   «Un .xlsx es un zip con archivos XML. descomprimirXlsx_ lo abre con Utilities.unzip y leerLibroXlsx_ lee el libro, las cadenas compartidas, los estilos para reconocer fechas y cada hoja. Devuelve cada celda como el texto que mostraría Excel. Esta parte es una función pura, así que se prueba en Node con los Excel reales.»

6. 7:00 – 8:30

   Deducir columnas e interpretar

   «Dominio.interpretar busca la fila de cabeceras, con sinónimos como TH por TOTAL HORAS. Si falta alguna columna, la deduce por su contenido: un código tiene la forma 3.1.1.24, una malla es un año, un semestre puede ser “1-2”, que significa semestre 1, grupo 2. Agrupa por código, ordena por semestre e ignora las filas de otra carrera. Este mismo código corre en el servidor y en el navegador.»

   Muestra: pegado con cabeceras (3.7) y sin cabeceras (3.10 y 3.12).

7. 8:30 – 10:00

   La carga masiva de la oferta

   «En la pantalla de carga hay tres opciones: pegar desde Google Sheets en una rejilla con aspecto de hoja, subir un archivo o descargar la plantilla. La rejilla muestra lo pegado y dice si reconoció las cabeceras antes de procesar. Para los libros de cálculo se usa SheetJS, que pesa casi un megabyte y por eso se descarga solo al entrar aquí. Si se reemplaza un plan, los grupos que siguen existiendo conservan su identificador y sus docentes.»

   Muestra: capturas 3.5 a 3.14.

8. 10:00 – 11:30

   La carga masiva de asignaciones

   «El director pega la hoja de su departamento de CargaXDepartamento, donde el nombre del docente aparece una vez y sus cursos debajo. interpretarCargaDepartamento recuerda el último docente, salta las filas de TOTAL y cruza cada fila con las secciones del ciclo por carrera, código y grupo. Cada fila queda en uno de cuatro estados, y los nombres que no están en el catálogo se resuelven con sugerencias antes de aplicar.»

   Muestra: capturas 3.16 a 3.21.

9. 11:30 – 12:00

   Cierre

   «En resumen: tres entradas, una sola forma de interpretar, ninguna carga rechazada y los archivos originales intactos. Los avisos explican lo que no se pudo leer, para que se corrija en el Excel.»

3.3Conceptos clave

Las tres entradas

Los archivos de la carpeta y cómo se reconocen

El nombre se normaliza (mayúsculas, sin tildes ni espacios) antes de buscar, en tipoDeFuente_ (FuenteDrive.js:94). Un archivo convertido a Hoja de Google se avisa con XLSX_CONVERTIDO y se ignora.

Columnas de la plantilla y cómo se deducen sin cabecera

Reglas de interpretación

Estados de una fila en la carga masiva de asignaciones

3.4Recorrido con capturas

Usa ?usuario=mfloresl@ulasalle.edu.pe para la oferta y ?usuario=jhuamanih@ulasalle.edu.pe (director de DIMA) para las asignaciones.

1. Los avisos de la lectura de Drive

   abre Registrar plan de ciclo en 2026-1.

   

   Verás

   Las 8 carreras en Registrado v1. La primera vez que alguien abre el tablero se leen los Excel; mientras, la página ya se muestra con lo que había.

   En el código

   datosIniciales_ no mira Drive para no retrasar la página: si hace falta, marca pendiente y el navegador pide obtenerTablero de fondo. ofertaDesdeLibros_ (OfertaXlsx.js:14) genera el aviso FILA_REPETIDA, que se guarda en Fuentes y se muestra a todos mientras el Excel no cambie.

2. Releer Excel

   pulsa Releer Excel.

   

   En el código

   cargarTablero({releer: true}) (Tablero.html:142) → obtenerTablero(ciclo, {releer: true}) → sincronizarFuentes_(true) (FuenteDrive.js:14), que mira la carpeta aunque la caché diga que se revisó hace poco y además vuelve a leer el catálogo de docentes (calentarCatalogo_(true)).

3. La firma de los archivos

   mira la pestaña Fuentes de la hoja del sistema.

   

   En el código

   fuentesIguales_ (FuenteDrive.js:157) compara «tipo|archivo_id|modificado» de lo guardado con lo actual. Si coinciden, no se descarga ningún archivo.

4. Problemas en la carpeta

   sube a la carpeta una segunda copia de CargaXCarrera y una versión convertida a Hoja de Google; pulsa Releer Excel.

   

   En el código

   localizarXlsx_ (FuenteDrive.js:108) recorre la carpeta, descarta las Hojas de Google con XLSX_CONVERTIDO, ordena los candidatos de cada tipo por fecha y avisa VARIOS_ARCHIVOS.

   Para la demo

   En la vista previa, los archivos se subieron a la carpeta simulada desde el script de capturas.

5. Un ciclo sin datos

   cambia el ciclo a 2026-2.

   

6. Las opciones de carga

   pulsa Editar en Ingeniería de Software.

   

   En el código

   entrarEnEdicion llama a irACarga (ImportarOferta.html:81) cuando el plan no tiene asignaturas. irACarga empieza a descargar SheetJS por si se sube un libro.

   Plantilla

   «Descargar plantilla oficial» genera en el navegador un .csv con BOM, separado por punto y coma, con las 11 columnas y una fila de ejemplo (Plantilla_Plan_Ciclo.csv).

7. Pegar un rango con cabeceras

   pulsa Pegar desde Google Sheets, copia un rango en Sheets (con su fila de cabeceras) y pulsa Ctrl+V.

   

   

   En el código

   crearRejillaPegado (Rejilla.html:92) escucha el evento paste del documento solo mientras la rejilla está a la vista, convierte el texto con matrizDesdeTexto y dibuja hasta 300 filas (se procesan todas). filaCabecera usa ubicarCabeceras para resaltar la fila.

8. Procesar: la fila de otra carrera se ignora

   pulsa Procesar contenido.

   

   En el código

   procesar (ImportarOferta.html:134) llama a interpretar(matriz, {carrera}), conserva los identificadores de los grupos que siguen existiendo (Dominio.conservarIds), marca el plan como sucio y pinta la grilla. Todavía no se guardó nada: el guardado es del bloque 4.

9. Pegar sin cabeceras

   desde la grilla, Reemplazar contenido → Continuar; pega un rango sin fila de cabeceras y con las columnas en otro orden.

   

   

   

   

   En el código

   deducirColumnas (Dominio.js:512) con las PISTAS (Dominio.js:469). Al reemplazar, las fusiones con otras carreras que se pierden se anotan en fusionesDisueltas para deshacerlas también en esos planes al guardar.

10. Subir un libro con varias hojas

    en otra carrera vacía, pulsa Subir archivo y elige SISCargaLectiva-Ejemplo-CargaXCarrera.xlsx.

    

    

    En el código

    leerArchivoComoMatriz (Rejilla.html:54): .xlsx, .xlsm, .xlsb, .xls y .ods se leen con SheetJS (XLSX.read, sheet_to_json con raw: false para tener el texto que se ve). Cualquier otra extensión, o un libro que no se deja leer, se lee como texto con matrizDesdeTexto. No hay extensiones prohibidas.

11. La pantalla de asignación del director

    abre la vista previa con ?usuario=jhuamanih@ulasalle.edu.pe y entra en Asignar docentes.

    

12. Pegar la hoja del departamento

    Editar asignaciones → Carga masiva; pega la hoja «CARGA DIMA 2026-I» o súbela con «Subir CargaXDepartamento».

    

    

    En el código

    Al subir el libro, leerArchivoDocentes (AsignacionCarga.html:93) elige sola la hoja cuyo nombre contiene la sigla del departamento de quien carga; si no la encuentra, pregunta.

13. Previsualizar antes de aplicar

    pulsa Previsualizar asignaciones.

    

    

    

    En el código

    interpretarCargaDepartamento (Dominio.js:1475) con ubicarColumnasCarga (:1402) y componentesDeFila (:1448). sugerirDocentes (:1381) ordena por similitudNombres: la parte de las palabras que comparten los dos nombres.

14. Aplicar

    elige a quién corresponde cada nombre y pulsa Aplicar a la asignación.

    

    En el código

    El botón «Aplicar» (AsignacionCarga.html:150) quita las asignaciones anteriores de cada componente que trae la hoja y pone las nuevas; lo demás de la carga se conserva. Las filas «fuera del plan» solo las agrega el director de la carrera.

3.5Catálogo de acciones y posibilidades

3.6Código clave comentado

Revisar la carpeta: leer fuera del candado, aplicar dentro

const f = localizarXlsx_(carpeta, avisos);
if (!f.carrera) { /* aviso FALTA_CARGA_CARRERA */ return avisos; }

const actuales = firmaFuentes_(f);                  // tipo, id, nombre, modificado
const guardadas = leerTabla_(TABLA_.FUENTES);
if (fuentesIguales_(guardadas, actuales)) return avisos.concat(avisosGuardados_(guardadas));
try {
  const lectura = leerOfertaXlsx_(f);               // lento: se hace SIN el candado
  const deLectura = conCandado_(function () {
    const otraVez = leerTabla_(TABLA_.FUENTES);       // ¿otro usuario ya lo procesó?
    if (fuentesIguales_(otraVez, actuales)) return avisosGuardados_(otraVez);
    const nuevos = aplicarOferta_(f, lectura);
    reemplazarFilas_(TABLA_.FUENTES, /* firma de cada archivo + avisos */);
    return nuevos;
  });
  return avisos.concat(deLectura);
} catch (e) {
  avisos.push(Dominio.aviso("LECTURA_XLSX_FALLIDA", "No se pudieron leer los xlsx de la carpeta: " + e.message));
  return avisos;
}

Aplicar la oferta plan por plan

Object.keys(r.oferta).forEach(function (sig) {
  const asignaturas = r.oferta[sig];
  const firma = Dominio.hash(Dominio.contenidoCanonico(asignaturas));
  const fila = buscarPlan_(planes, ciclo, sig);
  if (fila && fila.firma_xlsx === firma) return;        // esa hoja no cambió
  const p = estadoDePlan_(fila);
  const antes = p.version ? contenidoPlan_(ciclo, sig, p.version, p.filaVersion) : [];
  Dominio.conservarIds(asignaturas, antes);                 // los docentes siguen a sus grupos
  const fus = prepararFusiones_(ciclo, sig, antes, asignaturas, [], null, { sinBloqueo: true });
  registrarVersionPlan_(ciclo, sig, fila, {
    estado: p.estado === Dominio.ESTADOS.SIN ? Dominio.ESTADOS.REGISTRADO : p.estado,
    tipo: p.version ? Dominio.TIPO_VERSION.ACTUALIZACION_XLSX : Dominio.TIPO_VERSION.IMPORTACION_XLSX,
    usuario: "xlsx: " + f.carrera.getName(), fecha: Dominio.isoPeru(modificado),
    motivo: "", asignaturas: fus.asignaturas, firma_xlsx: firma
  });
  /* si la fusión tocó otros planes, se guardan y se relee Planes */
});

Leer una celda del XML de una hoja

if (ac.t === "s") texto = v != null ? (compartidas[parseInt(v, 10)] || "") : "";   // cadena compartida
else if (ac.t === "inlineStr") texto = xlsxTexto_(/* <is>…</is> */);            // texto en la celda
else if (ac.t === "b") texto = v === "1" ? "TRUE" : v != null ? "FALSE" : "";   // booleano
else if (ac.t === "str" || ac.t === "e" || ac.t === "d") texto = v != null ? xlsxDecodificar_(v) : "";
else if (v != null) {                                                       // número
  const formato = ac.s != null ? estilos[parseInt(ac.s, 10)] : null;
  texto = formato && isFinite(Number(v)) ? xlsxFormatearFecha_(Number(v), formato)  // con formato de fecha
                                         : xlsxNumero_(v);                          // como lo muestra «General»
}

Del texto pegado a una matriz

const lineas = String(txt).replace(/\r\n?/g, "\n").split("\n").filter(l => l.trim() !== "");
/* El separador se deduce del conjunto del texto, no de la primera línea:
   un rango pegado puede empezar con un título o una fila en blanco. */
if (lineas.some(l => l.includes("\t"))) return lineas.map(l => l.split("\t").map(c => c.trim()));
const cuenta = c => lineas.reduce((n, l) => n + (l.split(c).length - 1), 0);
const sep = cuenta(";") > cuenta(",") ? ";" : ",";
/* …y se separa respetando las comillas ("a;b" es una sola celda, "" es una comilla) */

Interpretar fila por fila

filas.forEach(f => {
  if (carrera && mapa.CARRERA !== undefined) {
    const c = val(f, "CARRERA");
    if (c && !coincideCarrera(c, carrera)) { ignoradas++; return; }    // otra carrera
  }
  const semBruto = val(f, "SEMESTRE");
  const ds = descomponerSemestre(semBruto);                          // «1-2» → sem 1, grupo 2
  const sem = !isNaN(ds.sem) ? ds.sem : (semBruto || "Sin semestre");
  const grupoBruto = val(f, "GRUPO");
  const grupo = grupoBruto !== "" ? grupoBruto : (!isNaN(ds.grupo) ? ds.grupo : 1);
  const codigo = val(f, "CODIGO"), nombre = val(f, "ASIGNATURA");
  const clave = codigo || nombre || ("fila-" + (++sinCodigo));      // cómo se agrupa
  if (!porClave.has(clave)) porClave.set(clave, { sem, malla: val(f, "MALLA"), codigo, nombre,
                                                dpto: val(f, "DPTO"), obs: val(f, "OBSERVACIONES"), grupos: [] });
  const a = porClave.get(clave);
  if (sinDuplicados && a.grupos.some(g => String(g.n) === String(grupo))) { duplicadas.push(/*…*/); return; }
  a.grupos.push(nuevoGrupo(grupo, val(f, "HT"), val(f, "HP")));      // horas tal cual
});

Clasificar una fila de CargaXDepartamento

for (let r = cab + 1; r < filas.length; r++) {
  const f = filas[r] || [];
  if (f.every(vacia) || f.some(c => /^\s*TOTAL/i.test(String(c == null ? "" : c)))) continue;
  docente = val(f, "DOCENTE") || docente;                // celdas combinadas: se arrastra el último
  /* … carrera, grupo (de GRUPO o de SEMESTRE «1-2»), HT, HP … */
  const seccion = (codigo && idx.get(carrera + "|C|" + codigo + "|" + n))
               || (nombre && idx.get(carrera + "|N|" + normalizar(nombre) + "|" + n)) || null;
  const estado = dest.carrera && deCarrera && deCarrera !== dest.carrera ? "otra-carrera"
    : !seccion ? "fuera"
    : dest.dpto && seccion.dpto !== dest.dpto ? "otro-dpto" : "ok";
}

3.7Errores, avisos y casos límite

3.8Preguntas probables

3.9Para practicar

• En 2026-2, pega un rango de la plantilla con una fila de otra carrera y explica la nota que aparece.
• Pega el mismo rango sin cabeceras y con las columnas desordenadas; explica qué pista reconoció cada columna.
• Guarda un .csv separado por punto y coma, súbelo y comprueba que se lee igual que el pegado.
• Como jhuamanih, pega la hoja de DIMA en la carga de ING y explica por qué las filas de ADM e IND quedan omitidas.
• Ejecuta la prueba del lector y explica qué compara.

node --test AppScript/pruebas/lector.test.mjs

4.1Ficha del bloque

Pregunta que responde

¿Cómo registra el coordinador el plan de ciclo de su carrera: qué asignaturas y grupos abre, con qué horas, y cómo lo deja listo para asignar docentes?

Archivos del servidor

Planes.js 353Fusiones.js 62

Archivos del navegador

Tablero.html 310Grilla.html 273GrillaAcciones.html 303GrillaEdicion.html 370

Parte de Dominio.js

L612–648 totalesL649–886 operaciones de ediciónL887–1018 fusiones entre carreras

Usa

El bloque 2 para el bloqueo, las versiones y la recuperación; el bloque 3 para la carga masiva; Acceso.js para los permisos.

Pruebas

dominio.test.mjs (operaciones y totales), servidor.test.mjs (endpoints con Google simulado) y recorrido-ui.mjs (el recorrido en Chrome).

Idea central

Todo se edita en el navegador con las funciones de Dominio, sin llamar al servidor; el servidor solo interviene al abrir, guardar, restaurar o derivar, y vuelve a comprobarlo todo.

4.2Guion de exposición · unos 13 minutos

1. 0:00 – 1:00

   Qué es un plan de ciclo

   «El plan de ciclo es la oferta de una carrera en un ciclo: sus asignaturas por semestre, y de cada asignatura sus grupos con horas de teoría y de práctica. Pasa por tres estados: Sin Iniciar, Borrador y Registrado. Registrarlo habilita la asignación docente. Un plan registrado se sigue pudiendo editar, pero nunca vuelve a borrador, y cada guardado deja una versión.»

   Muestra: el diagrama de estados.

2. 1:00 – 2:30

   Inicio y tablero

   «El inicio resume el ciclo: planes registrados, en borrador, sin iniciar, grupos y horas de dictado. El tablero lista las ocho carreras con su estado, totales, versión y quién lo está editando. El botón Editar solo aparece en las carreras que coordina la cuenta. El tablero trae además el contenido vigente de cada plan, así que consultar o empezar a editar no espera al servidor.»

   Muestra: capturas 4.1, 4.2 y 4.3.

3. 2:30 – 3:30

   Consultar en solo lectura

   «Al pulsar una fila se consulta el plan: el resumen de nueve cifras y un bloque por semestre. La columna Docente se llena aparte, en segundo plano, con las asignaciones vigentes.»

   Muestra: captura 4.4.

4. 3:30 – 5:00

   Entrar en edición y la grilla

   «Editar abre la grilla al instante, mientras el bloqueo se pide de fondo; hasta que llega no se puede guardar. Arriba, la nota del estado y el resumen; después los semestres, que se pueden plegar. Al seleccionar un grupo aparece en el dock inferior con las acciones que le aplican.»

   Muestra: capturas 4.5 a 4.7.

5. 5:00 – 7:30

   Editar sin validar

   «Se pueden editar las horas, que se guardan tal como se escriben; editar los datos de la asignatura; agregar asignaturas o grupos, uno o a todo un semestre; y eliminar. Antes de eliminar un grupo que ya tiene docente se avisa: la asignación no se borra, queda pendiente para que el director la reasigne. El desdoble divide la práctica o la teoría de un grupo en dos a cinco subgrupos y se marca, por ejemplo, PRA×3.»

   Muestra: capturas 4.8 a 4.15.

6. 7:30 – 9:30

   Fusiones

   «Fusionar une grupos en una sola sección con un docente. Se elige un grupo principal y los demás toman sus horas; las horas de antes se guardan para poder deshacer. Si los grupos difieren en nombre, código u horas, se advierte con A05 pero se fusiona igual. Se puede fusionar con grupos de otra carrera: al guardar, el servidor lleva la fusión a ese otro plan, con una versión de tipo fusión, salvo que alguien lo esté editando. En las horas de dictado, la sección fusionada cuenta una sola vez.»

   Muestra: capturas 4.16 a 4.22.

7. 9:30 – 11:30

   Guardar y registrar

   «Hay tres formas de guardar: Guardar borrador, Registrar plan, que muestra el resumen y pide confirmar, y Guardar cambios cuando ya está registrado, con un motivo opcional. Al registrar se ve la pantalla de éxito con tres caminos: volver al tablero, seguir editando o ir a asignar docentes. El historial permite restaurar cualquier versión.»

   Muestra: capturas 4.24 a 4.29.

8. 11:30 – 12:30

   Derivar un curso a otro departamento

   «Por regla, los docentes de una carrera los asigna el departamento de esa carrera. La excepción es derivar un curso: el director del departamento que hoy lo asigna, o el coordinador, lo pasa a otro departamento desde la consulta. Se guarda como versión “cambio de departamento”, la columna DPTO del Excel no cambia y las asignaciones siguen al curso.»

   Muestra: capturas 4.30 a 4.32.

9. 12:30 – 13:00

   Cierre

   «El navegador edita con el mismo Dominio que usa el servidor; el servidor solo recibe el plan completo al guardar, lo sanea, comprueba permiso, bloqueo y conflicto, reconcilia las fusiones y guarda la versión.»

4.3Conceptos clave

Estados del plan

El modelo de datos

[
  {
    "sem": 1, "malla": "2024", "codigo": "3.1.1.24", "nombre": "Introducción a la Programación",
    "dpto": "DIMA",               // columna DPTO del Excel: solo informativa
    "obs": "",                    // INTERNACIONAL o VIRTUAL la marcan como «Intl.»
    "derivado": "DAHUC",          // opcional: lo asigna otro departamento
    "grupos": [
      { "id": "g8k2…", "n": 1, "ht": "2", "hp": "4",
        "desdoble": "PRA×3",      // o null
        "fusion": null },         // marca «F…» si está fusionado
      { "id": "g1x9…", "n": 2, "ht": "2", "hp": "4", "desdoble": null,
        "fusion": "FQ3K7ZB", "fusionPrincipal": true,
        "fusionCon": [ { "carrera": "IND", "grupoId": "g7…", "codigo": "17.1.5.24", "n": 1, "principal": false } ],
        "previas": { "ht": "3", "hp": "2" } }   // horas antes de fusionar, para deshacer
    ]
  }
]

Las nueve cifras del resumen

Tipos de versión

Quién puede hacer qué

Qué pasa al guardar, en el servidor

4.4Recorrido con capturas

Usa ?usuario=mfloresl@ulasalle.edu.pe (coordinador de todas las carreras) y, para derivar, ?usuario=jhuamanih@ulasalle.edu.pe (director de DIMA).

1. El inicio

   abre la aplicación.

   

   En el código

   pintarInicio (Inicio.html) calcula todo con las filas del tablero que trajo la página; no llama al servidor.

2. El tablero

   entra en Registrar plan de ciclo.

   

   

   En el código

   pintarTablero (Tablero.html:187) y pintarAvance (:225). Si los datos tienen más de 15 s, mostrarTablero los vuelve a pedir de fondo (VIGENCIA_TABLERO_MS). Cambiar de ciclo vuelve a leer.

3. Consultar un plan

   pulsa la fila de Derecho.

   

   En el código

   abrirLectura (Tablero.html:245) usa el contenido que trajo el tablero; solo si no lo tiene llama a obtenerPlan. Los docentes llegan aparte con obtenerDocentesPorGrupo y, cuando llegan, se repinta.

4. La grilla de edición

   vuelve al tablero y pulsa Editar en Ingeniería de Software.

   

   En el código

   pintarGrilla (Grilla.html:177): el botón principal dice «Registrar plan» o «Guardar cambios» según el estado; «Guardar borrador» se desactiva en un plan registrado; los dos esperan a que el bloqueo esté confirmado (p.confirmado).

5. Seleccionar un grupo

   pulsa una fila de la grilla.

   

   

6. Editar horas y datos de la asignatura

   con un grupo seleccionado, pulsa Editar HT / HP y luego Editar asignatura.

   

   

7. Agregar una asignatura o grupos

   pulsa Agregar asignatura; después selecciona un grupo y pulsa Agregar grupo; prueba también Agregar grupo al semestre.

   

   

   

   En el código

   Dominio.agregarAsignatura (L660) reordena por semestre y código; agregarGrupo (L692) y agregarGrupoSemestre (L705) usan siguienteN.

8. Desdoblar

   selecciona un grupo, pulsa Desdoblar, elige Práctica y 3 subgrupos.

   

   

   

   Validación

   Si el grupo no tiene horas del tipo elegido: «El desdoble no aplica». Si la cantidad no está entre 2 y el máximo: «Cantidad de subgrupos no válida» y se vuelve a preguntar. Son las únicas validaciones del plan, y no rechazan nada guardado.

9. Fusionar grupos del mismo plan

   pulsa Fusionar grupos, marca dos grupos con Ctrl y elige el principal.

   

   

   

   

   En el código

   Dominio.fusionar (L803) crea la marca «F» + 6 caracteres, guarda las horas previas de los no principales en previas, les copia las del principal y devuelve las diferencias para A05. Si un grupo ya estaba en otra fusión, la anterior se limpia con limpiarFusionHuerfana.

10. Deshacer la fusión y eliminar

    selecciona un grupo fusionado y pulsa Deshacer fusión; prueba también Eliminar grupo y Eliminar asignatura.

    

    

    

    En el código

    Antes de eliminar se llama a asegurarDocentesGrupo (Tablero.html:106) para saber si hay docentes asignados. Una fusión que se queda con menos de dos grupos se deshace sola.

11. Fusionar con otra carrera

    en el diálogo de fusión marca un grupo de ING (Cálculo I) y uno de IND que está más abajo en la lista (Matemática y álgebra lineal); el principal es el de ING.

    

    

    En el servidor

    prepararFusiones_ (Fusiones.js:21) pide a Dominio.reconciliarFusiones (L934) cómo quedan las fusiones en todos los planes del ciclo; si alguno de esos planes lo edita otra cuenta, falla con BLOQUEADO y no se guarda nada. guardarFusionesAjenas_ (:50) registra en cada plan tocado una versión «fusión».

    Regla

    Desde un plan solo se fusionan secciones que incluyan al menos un grupo suyo: si se eligen solo grupos ajenos, se pide volver a seleccionar.

12. Plegar los semestres

    pulsa Colapsar todo (o la cabecera de un semestre).

    

13. Guardar cambios de un plan registrado

    pulsa Guardar cambios, escribe un motivo y confirma.

    

    

14. Registrar un plan nuevo

    en un plan en Sin Iniciar o Borrador, pulsa Registrar plan.

    

    

15. Guardar como borrador

    en un plan que todavía no está registrado, pulsa Guardar borrador.

    

    

    

16. Derivar un curso a otro departamento

    con ?usuario=jhuamanih@ulasalle.edu.pe (director de DIMA), consulta ING y pulsa Derivar en un curso.

    

    

    

    En el código

    derivarAsignatura (Tablero.html:299) → cambiarDepartamento (Planes.js:321): comprueba que quien deriva sea el director del departamento que hoy lo asigna o el coordinador de la carrera, que el plan no lo edite otra cuenta, y guarda una versión «cambio de departamento» con el motivo «código nombre: DIMA → DAHUC».

4.5Catálogo de acciones y posibilidades

4.6Código clave comentado

El endpoint de guardado

function guardarPlan(ciclo, sig, datos) {
  return responder_(function () {                               // contrato {ok, datos}
    const usuario = exigirUsuario_();
    const c = validarCiclo_(ciclo), s = validarCarrera_(sig);
    exigirEdicion_(usuario, s);                                    // SIN_PERMISO si no coordina
    const T = Dominio.TIPO_VERSION;
    if (!datos || [T.BORRADOR, T.REGISTRAR, T.CAMBIOS, T.AUTOGUARDADO].indexOf(datos.tipo) < 0)
      fallo_("DATO_INVALIDO", "Tipo de guardado desconocido.");
    const recibidas = Dominio.sanearAsignaturas(datos.asignaturas);   // nunca se confía en el navegador
    const disueltas = Dominio.sanearMarcas(datos.fusionesDisueltas);

    return conCandado_(function () {
      const b = exigirSinBloqueoAjeno_(c, s, usuario, "no se guardó");
      const fila = filaPlan_(c, s);
      const p = estadoDePlan_(fila);
      const conflicto = datos.forzar ? null : conflictoPlan_(c, s, p.version, datos.versionBase);
      if (conflicto) fallo_("CONFLICTO", "Mientras editabas se guardó la versión v" + conflicto.n + " del plan.", conflicto);
      const estado = resolverEstado_(p.estado, datos.estado);         // Registrado no vuelve atrás
      const fecha = Dominio.isoPeru();
      const antes = p.version ? contenidoPlan_(c, s, p.version, p.filaVersion) : [];
      const f = prepararFusiones_(c, s, antes, recibidas, disueltas, usuario);
      const n = registrarVersionPlan_(c, s, fila, {
        estado: estado, tipo: datos.tipo, usuario: usuario.correo, fecha: fecha,
        motivo: String(datos.motivo || "").slice(0, 500), asignaturas: f.asignaturas
      });
      const otros = guardarFusionesAjenas_(c, f.otros, usuario.correo, fecha);
      borrarRecuperacion_(c, Dominio.REF.plan(s), usuario.correo);
      const r = b ? tomarBloqueo_(c, Dominio.REF.plan(s), usuario.correo) : null;   // renueva
      return { version: n, estado: estado, fecha: fecha, expira: r && r.ok ? r.expira : null,
               asignaturas: f.asignaturas, otros: otros };
    });
  });
}

Las horas de dictado

(asignaturas || []).forEach(a => a.grupos.forEach(g => {
  if (!g.fusion) return;
  if (g.fusionPrincipal) principalAqui.add(g.fusion);
  if ((g.fusionCon || []).some(x => x.principal)) principalFuera.add(g.fusion);
}));
(asignaturas || []).forEach(a => {
  t.asig++; sems.add(a.sem);
  if (esInternacional(a)) t.intl++;
  a.grupos.forEach(g => {
    t.grupos++; t.ht += num(g.ht); t.hp += num(g.hp); t.th += th(g);
    if (g.desdoble) t.des++;
    if (g.fusion) {
      if (!fus.has(g.fusion)) {                                 // la sección cuenta una vez…
        fus.add(g.fusion);
        if (principalAqui.has(g.fusion) || !principalFuera.has(g.fusion)) t.dictado += th(g);  // …en el plan del principal
      }
    }
    else t.dictado += th(g);
  });
});

Fusionar: el principal define las horas

locales.forEach(v => {
  const s = par(v);                                          // {a, g} de "ci:gi"
  const esPrincipal = !!pLocal && s.g === pLocal.g;
  if (!esPrincipal && difiereDe(s.a.nombre, s.a.codigo, s.g.ht, s.g.hp, ref))
    difs.push(s.a.codigo + " " + s.a.nombre + " (grupo " + s.g.n + ")");   // → advertencia A05
  if (s.g.fusion && s.g.fusion !== marca) anteriores.add(s.g.fusion);
  if (!esPrincipal && (s.g.ht !== ref.ht || s.g.hp !== ref.hp) && !s.g.previas)
    s.g.previas = { ht: s.g.ht, hp: s.g.hp };                    // para deshacer
  s.g.fusion = marca;
  if (esPrincipal) s.g.fusionPrincipal = true; else delete s.g.fusionPrincipal;
  if (fusionCon.length) s.g.fusionCon = fusionCon.map(x => Object.assign({}, x)); else delete s.g.fusionCon;
  if (!esPrincipal) { s.g.ht = ref.ht; s.g.hp = ref.hp; }        // toma las horas del principal
});
anteriores.forEach(m => limpiarFusionHuerfana(asignaturas, m));

Reconciliar fusiones entre carreras

Validar el desdoble en el navegador

const { tipo: clase, cant } = r();
const horas = num(clase === "Práctica" ? s.g.hp : s.g.ht);
const n = parseInt(cant, 10);
if (!horas) {
  await informar("El desdoble no aplica", "El grupo no registra horas de " + clase.toLowerCase() + "…");
  return;
}
if (!(n >= 2 && n <= CONFIG.maxSubgrupos)) {
  await informar("Cantidad de subgrupos no válida", "…entre 2 y " + CONFIG.maxSubgrupos + "…");
  return accion("desdoblar");                                // vuelve a preguntar
}
Dominio.desdoblar(s.g, clase, n);                             // g.desdoble = "PRA×3"

Permiso para derivar

const propio = Dominio.dptoDeCarrera(s);                                  // ING → DIMA
const actual = Dominio.DPTOS.indexOf(a.derivado) >= 0 ? a.derivado : propio;   // quién lo asigna hoy
const esDirector = usuario.rol === "director" && !!usuario.departamento && usuario.departamento === actual;
if (!esDirector && usuario.carreras.indexOf(s) < 0) fallo_("SIN_PERMISO", /* … */);
if (actual === d) return { /* … */ sinCambios: true };
exigirSinBloqueoAjeno_(c, s, usuario, "el cambio de departamento no se guardó");
if (d === propio) delete a.derivado; else a.derivado = d;           // volver al propio quita la derivación

4.7Errores, avisos y casos límite

4.8Preguntas probables

4.9Para practicar

• Edita ING, desdobla un grupo y fusiona dos; explica por qué bajan las horas de dictado pero no el total de horas.
• Fusiona un grupo de ING con uno de IND, guarda y comprueba en el tablero que IND tiene una versión nueva.
• En 2026-2, arma un plan con la carga masiva, guárdalo como borrador y luego regístralo; mira los dos tipos en el historial.
• Como director de DIMA, deriva un curso de ING a DAHUC y entra como jortizc para ver que ahora lo asigna DAHUC.
• Ejecuta las pruebas del dominio y del servidor, y el recorrido en Chrome.

node --test AppScript/pruebas/dominio.test.mjs AppScript/pruebas/servidor.test.mjs

node AppScript/pruebas/recorrido-ui.mjs

En Windows, el recorrido necesita la ruta de Chrome en la variable CHROME, por ejemplo C:/Program Files/Google/Chrome/Application/chrome.exe.