302 lines
13 KiB
TypeScript
302 lines
13 KiB
TypeScript
/*
|
|
Verse dans la GED Dolibarr les pièces déclarées par gedManifest.ts.
|
|
|
|
POURQUOI CE N'EST PAS UN SIMPLE UPLOAD : la GED de Dolibarr est pilotée par
|
|
les objets. `/ecm/index_auto.php` expose les documents rattachés à une facture,
|
|
un tiers, une charge ; `/ecm/index.php` n'expose que les répertoires MANUELS,
|
|
enregistrés en base. Déposer un fichier via l'API dans un chemin libre le pose
|
|
bien sur le disque, mais aucun écran ne le montrera jamais — l'API accepte
|
|
n'importe quel `subdir` sans broncher. Vérifié le 2026-08-13 : un dépôt dans
|
|
`ecm/social/urssaf/2026` laissait l'arbre GED vide.
|
|
|
|
Il faut donc CRÉER le répertoire par l'UI (seule voie qui l'inscrive en base),
|
|
puis y téléverser par l'API. C'est ce que fait ce script.
|
|
|
|
Les pièces qui justifient un fait comptable n'ont rien à faire ici : elles se
|
|
rattachent à leur objet. Le PDF de l'appel URSSAF est attaché aux charges, une
|
|
facture fournisseur à sa facture. La GED manuelle est pour ce qui n'a pas
|
|
d'objet : statuts, KBIS, registre des décisions, convention de domiciliation.
|
|
|
|
Idempotent : un répertoire déjà présent n'est pas recréé, un fichier déjà
|
|
présent est réécrit à l'identique (`overwriteifexists`).
|
|
|
|
Tout passe par l'UI — répertoires ET fichiers. L'API REST n'est pas une
|
|
alternative ici : voir le commentaire de `upload()`, elle répond succès sans
|
|
rien déposer que la GED sache retrouver.
|
|
|
|
Usage :
|
|
deno run -A test/provisionGed.ts --docs ~/Work/Arcodange/1_DOCUMENTS [--dry-run]
|
|
*/
|
|
import "load_dotenv";
|
|
import { chromium, type Page } from "playwright";
|
|
import login from "./scripts/login.ts";
|
|
import { assertSandbox } from "./scripts/guard.ts";
|
|
import { DIRS, FILES } from "./gedManifest.ts";
|
|
|
|
const argv = Deno.args;
|
|
const pick = (f: string, d = "") => (argv.includes(f) ? argv[argv.indexOf(f) + 1] : d);
|
|
|
|
const docsRoot = pick("--docs", `${Deno.env.get("HOME")}/Work/Arcodange/1_DOCUMENTS`)
|
|
.replace(/^~/, Deno.env.get("HOME") ?? "~");
|
|
const dryRun = argv.includes("--dry-run");
|
|
|
|
const dolibarrAddress = assertSandbox();
|
|
|
|
console.log(`cible : ${dolibarrAddress}`);
|
|
console.log(`source : ${docsRoot}`);
|
|
console.log(`manifeste : ${DIRS.length} répertoires, ${FILES.length} pièces\n`);
|
|
|
|
// Une pièce absente du disque est une erreur de manifeste, pas un incident à
|
|
// ignorer : on refuse de partir plutôt que de livrer un versement partiel dont
|
|
// personne ne saura ce qui manque.
|
|
const missing = FILES.filter((f) => {
|
|
try {
|
|
return !Deno.statSync(`${docsRoot}/${f.src}`).isFile;
|
|
} catch {
|
|
return true;
|
|
}
|
|
});
|
|
if (missing.length) {
|
|
console.error("INTROUVABLES — le manifeste ne correspond plus au disque :");
|
|
for (const m of missing) console.error(` ${m.src}`);
|
|
Deno.exit(1);
|
|
}
|
|
|
|
if (dryRun) {
|
|
for (const d of DIRS) console.log(` répertoire ${d.parent ? d.parent + "/" : ""}${d.label}`);
|
|
for (const f of FILES) console.log(` pièce ${f.dir}/${f.as} ← ${f.src}`);
|
|
console.log("\n--dry-run : rien n'est écrit.");
|
|
Deno.exit(0);
|
|
}
|
|
|
|
/**
|
|
* L'arbre GED, lu tel qu'il est : chemin de chaque répertoire → nombre de
|
|
* documents qu'il porte.
|
|
*
|
|
* DEUX PIÈGES, tous deux rencontrés :
|
|
* - l'arbre est un arbre jQuery REPLIÉ. `innerText` sur son conteneur renvoie
|
|
* une chaîne vide alors que les répertoires existent — conclure de là qu'ils
|
|
* manquent fait relancer la création, qui répond « existe déjà », et le
|
|
* script annonce l'échec d'une opération réussie ;
|
|
* - ses ancres portent `href="#"`, pas `section=`. Le chemin vit dans
|
|
* l'attribut `rel` (« Juridique/Identite/ »). Chercher un lien `section=`
|
|
* ne ramène rien, quel que soit le contenu réel de l'arbre.
|
|
* Les nœuds repliés restent dans le DOM : `evaluateAll` les atteint.
|
|
*/
|
|
async function readTree(page: Page): Promise<Map<string, { id: number; docs: number }>> {
|
|
await page.goto(`${dolibarrAddress}/ecm/index.php`);
|
|
// L'arbre est monté par jQuery APRÈS le chargement : lire tout de suite ne
|
|
// ramène rien et fait conclure à un arbre vide.
|
|
await page.waitForSelector("li.lidirecm", { timeout: 15000 }).catch(() => {});
|
|
|
|
// Et il ne monte QUE la racine : les sous-répertoires arrivent par ajax au
|
|
// dépliage. Sans cette boucle, tout ce qui n'est pas à la racine est déclaré
|
|
// absent alors qu'il existe. On déplie jusqu'à stabilisation, en bornant les
|
|
// passes — un arbre qui ne se stabilise pas est un bug, pas une raison de
|
|
// tourner indéfiniment.
|
|
for (let pass = 0; pass < 6; pass++) {
|
|
const collapsed = page.locator("li.directory.collapsed > a.fmdirlia");
|
|
const n = await collapsed.count();
|
|
if (n === 0) break;
|
|
for (let i = 0; i < n; i++) {
|
|
await collapsed.nth(i).click({ timeout: 5000 }).catch(() => {});
|
|
}
|
|
await page.waitForTimeout(600);
|
|
}
|
|
|
|
const rows = await page.locator("li.lidirecm").evaluateAll(
|
|
// Deno n'embarque pas la lib DOM : le callback s'exécute dans le navigateur.
|
|
(lis: {
|
|
querySelector(s: string): { getAttribute(n: string): string | null } | null;
|
|
querySelectorAll(s: string): ArrayLike<{ textContent: string | null }>;
|
|
}[]) =>
|
|
lis.map((li) => {
|
|
const a = li.querySelector("a.fmdirlia");
|
|
const cells = Array.from(li.querySelectorAll("td.right"));
|
|
// L'identifiant de section ne vit que dans le handler : loadandshowpreview('chemin',ID)
|
|
const id = Number((a?.getAttribute("onclick") ?? "").match(/,\s*(\d+)\s*\)/)?.[1] ?? "0");
|
|
return {
|
|
path: (a?.getAttribute("rel") ?? "").replace(/\/$/, ""),
|
|
id,
|
|
docs: Number((cells[0]?.textContent ?? "").trim() || "0"),
|
|
};
|
|
}),
|
|
);
|
|
return new Map(rows.filter((r) => r.path).map((r) => [r.path, { id: r.id, docs: r.docs }]));
|
|
}
|
|
|
|
/** Chemin d'un répertoire du manifeste, tel que l'arbre et l'API le nomment. */
|
|
const pathOf = (label: string): string => {
|
|
const d = DIRS.find((x) => x.label === label);
|
|
return d?.parent ? `${pathOf(d.parent)}/${label}` : label;
|
|
};
|
|
|
|
/**
|
|
* Crée un répertoire. Le formulaire est la seule autorité sur l'existant :
|
|
* il répond « existe déjà », ce qui vaut succès pour un script idempotent.
|
|
*/
|
|
async function createDir(page: Page, label: string, parent: string | null, desc: string): Promise<"créé" | "déjà présent"> {
|
|
await page.goto(`${dolibarrAddress}/ecm/dir_add_card.php?action=create&module=ecm`);
|
|
await page.fill('input[name="label"]', label);
|
|
await page.fill('textarea[name="desc"]', desc).catch(() => {});
|
|
if (parent) {
|
|
// Le select des parents porte les répertoires déjà créés ; on l'apparie sur
|
|
// le libellé visible, jamais sur un id qui diffère d'une instance à l'autre.
|
|
const opts = await page.locator('select[name="catParent"] option').evaluateAll(
|
|
(os: { textContent: string | null; getAttribute(n: string): string | null }[]) =>
|
|
os.map((o) => ({
|
|
text: (o.textContent ?? "").trim(),
|
|
value: o.getAttribute("value") ?? "",
|
|
})),
|
|
);
|
|
const hit = opts.find((o) => o.text === parent) ?? opts.find((o) => o.text.includes(parent));
|
|
if (!hit) {
|
|
throw new Error(`parent « ${parent} » absent du select (options : ${opts.map((o) => o.text).join(", ")})`);
|
|
}
|
|
await page.selectOption('select[name="catParent"]', hit.value);
|
|
}
|
|
await page.locator('input[name="create"], input[type="submit"]').first().click();
|
|
await page.waitForLoadState("networkidle");
|
|
const body = (await page.locator("body").innerText()).replace(/\s+/g, " ");
|
|
if (/existe d[ée]j[àa]/i.test(body)) return "déjà présent";
|
|
const err = body.match(/Erreur[^.]{0,160}/i);
|
|
if (err) throw new Error(`${label} : ${err[0]}`);
|
|
return "créé";
|
|
}
|
|
|
|
/**
|
|
* Téléverse une pièce dans un répertoire de la GED, par le formulaire de l'UI.
|
|
*
|
|
* POURQUOI PAS L'API. `POST /documents/upload` avec `modulepart=ecm` répond le
|
|
* nom du fichier — donc succès — et ne dépose RIEN que la GED sache retrouver :
|
|
* l'arbre affiche « Pas de documents téléversés » et `/documents/download`
|
|
* répond 404 sur le chemin qu'on vient d'écrire. Vérifié le 2026-08-13 sur les
|
|
* onze pièces. Le formulaire de l'UI, lui, écrit au bon endroit ET inscrit le
|
|
* fichier à l'index — c'est cet index qui alimente les compteurs et la
|
|
* recherche. Une pièce non indexée est une pièce perdue.
|
|
*
|
|
* Le renommage passe par une copie temporaire : le formulaire envoie le nom du
|
|
* fichier sur disque, il n'offre aucun champ pour le choisir.
|
|
*/
|
|
/** Noms des fichiers réellement présents dans un répertoire de la GED. */
|
|
async function filesIn(page: Page, sectionId: number): Promise<Set<string>> {
|
|
await page.goto(`${dolibarrAddress}/ecm/index.php?section=${sectionId}&file_manager=1`);
|
|
await page.waitForTimeout(800);
|
|
const hrefs = await page.locator('a[href*="document.php"]').evaluateAll(
|
|
(as: { getAttribute(n: string): string | null }[]) =>
|
|
as.map((a) => (a.getAttribute("href") ?? "").match(/file=([^&]+)/)?.[1] ?? "").filter(Boolean),
|
|
);
|
|
return new Set(hrefs.map((h) => decodeURIComponent(h).split("/").pop() ?? ""));
|
|
}
|
|
|
|
async function upload(page: Page, f: typeof FILES[number], sectionId: number, tmp: string): Promise<"versé" | "déjà présent"> {
|
|
// Idempotence par le NOM, pas par la case « écraser » du formulaire : celle-ci
|
|
// ne s'applique pas de façon fiable et chaque passe ajoutait un doublon — deux
|
|
// exemplaires du même statut dans la GED, personne ne sachant lequel fait foi.
|
|
if ((await filesIn(page, sectionId)).has(f.as)) return "déjà présent";
|
|
|
|
const staged = `${tmp}/${f.as}`;
|
|
await Deno.copyFile(`${docsRoot}/${f.src}`, staged);
|
|
|
|
await page.goto(`${dolibarrAddress}/ecm/index.php?section=${sectionId}&file_manager=1`);
|
|
await page.waitForSelector('input[name="userfile[]"]', { timeout: 15000 });
|
|
|
|
// Au-delà de MAX_FILE_SIZE, le formulaire accepte la soumission, n'écrit rien
|
|
// et n'affiche aucune erreur : le fichier disparaît sans bruit. C'est ainsi
|
|
// qu'un bail de 8,6 Mo a été porté « versé » alors qu'il ne l'était pas.
|
|
const limit = Number(
|
|
await page.locator('input[name="MAX_FILE_SIZE"]').first().getAttribute("value") ?? "0",
|
|
);
|
|
const size = (await Deno.stat(staged)).size;
|
|
if (limit && size > limit) {
|
|
throw new Error(
|
|
`${f.as} : ${(size / 1048576).toFixed(1)} Mo dépasse la limite de ` +
|
|
`${(limit / 1048576).toFixed(1)} Mo. Relever MAIN_UPLOAD_DOC (Dolibarr) ` +
|
|
`et upload_max_filesize (PHP), ou retirer la pièce du manifeste.`,
|
|
);
|
|
}
|
|
|
|
await page.setInputFiles('input[name="userfile[]"]', staged);
|
|
await page.locator('input[name="overwritefile"]').check().catch(() => {});
|
|
await Promise.all([
|
|
page.waitForLoadState("networkidle"),
|
|
page.locator('input[name="sendit"]').click(),
|
|
]);
|
|
|
|
const body = (await page.locator("body").innerText()).replace(/\s+/g, " ");
|
|
const err = body.match(/Erreur[^.]{0,160}/i);
|
|
if (err) throw new Error(`${f.as} : ${err[0]}`);
|
|
|
|
// Relire : le formulaire sait échouer sans le dire.
|
|
if (!(await filesIn(page, sectionId)).has(f.as)) {
|
|
throw new Error(`${f.as} : absent du répertoire après téléversement`);
|
|
}
|
|
return "versé";
|
|
}
|
|
|
|
const browser = await chromium.launch({ headless: true });
|
|
const context = await browser.newContext({ locale: "fr-FR" });
|
|
const page = await context.newPage();
|
|
|
|
try {
|
|
await login.doAdminLogin({
|
|
page,
|
|
dolibarrAddress,
|
|
adminCredentials: {
|
|
username: Deno.env.get("DOLI_ADMIN_LOGIN") || "undefined",
|
|
password: Deno.env.get("DOLI_ADMIN_PASSWORD") || "undefined",
|
|
},
|
|
});
|
|
|
|
// Les parents d'abord : le select ne peut proposer que ce qui existe déjà.
|
|
const ordered = [...DIRS].sort((a, b) => (a.parent ? 1 : 0) - (b.parent ? 1 : 0));
|
|
for (const d of ordered) {
|
|
const state = await createDir(page, d.label, d.parent, d.desc);
|
|
console.log(` ${state === "créé" ? "+" : "="} ${pathOf(d.label)} (${state})`);
|
|
}
|
|
|
|
console.log("");
|
|
const sections = await readTree(page);
|
|
const tmp = await Deno.makeTempDir({ prefix: "arcodange-ged-" });
|
|
try {
|
|
for (const f of FILES) {
|
|
const dir = sections.get(pathOf(f.dir));
|
|
if (!dir) throw new Error(`répertoire ${pathOf(f.dir)} introuvable dans l'arbre`);
|
|
const state = await upload(page, f, dir.id, tmp);
|
|
console.log(` ${state === "versé" ? "+" : "="} ${pathOf(f.dir)}/${f.as} (${state})`);
|
|
}
|
|
} finally {
|
|
await Deno.remove(tmp, { recursive: true }).catch(() => {});
|
|
}
|
|
|
|
// Vérification finale par les NOMS, jamais par un compteur : un compteur juste
|
|
// peut recouvrir deux exemplaires d'une pièce et l'absence d'une autre.
|
|
const bad: string[] = [];
|
|
const extra: string[] = [];
|
|
for (const d of DIRS) {
|
|
const path = pathOf(d.label);
|
|
const sec = sections.get(path);
|
|
if (!sec) {
|
|
bad.push(`${path} : absent de l'arbre`);
|
|
continue;
|
|
}
|
|
const present = await filesIn(page, sec.id);
|
|
const wanted = FILES.filter((f) => f.dir === d.label).map((f) => f.as);
|
|
for (const w of wanted) if (!present.has(w)) bad.push(`${path}/${w} : absent`);
|
|
for (const p of present) if (!wanted.includes(p)) extra.push(`${path}/${p}`);
|
|
}
|
|
if (extra.length) {
|
|
console.warn("\nPièces présentes hors manifeste (à examiner, rien n'a été supprimé) :");
|
|
for (const e of extra) console.warn(` ${e}`);
|
|
}
|
|
if (bad.length) {
|
|
console.error("\nVERSEMENT INCOMPLET :");
|
|
for (const b of bad) console.error(` ${b}`);
|
|
Deno.exit(1);
|
|
}
|
|
console.log(`\n${DIRS.length} répertoires, ${FILES.length} pièces — chaque pièce vérifiée par son nom dans la GED.`);
|
|
} finally {
|
|
await context.close();
|
|
await browser.close();
|
|
}
|