Reprendre votre dossier JD2M dans Locameublé

// Export JD2M vers Locameublé : lecture seule (GET), à lancer sur app.jedeclaremonmeuble.com, connecté.
// Console : coller ce fichier. Favori : "javascript:" + encodeURIComponent(ce fichier).
(async () => {
  const HOTE = "app.jedeclaremonmeuble.com";
  const API = "/apis/public/1.0";
  /** @type {(message: string) => never} */
  const stop = (message) => {
    alert(`Export JD2M\n\n${message}`);
    throw new Error(message);
  };
  if (location.hostname !== HOTE)
    stop(
      `Ouvrez https://${HOTE}/myspace/, connectez-vous, puis relancez l'export depuis cet onglet.`,
    );
  const token =
    sessionStorage.getItem("token") ||
    stop(
      "Vous n'êtes pas connecté dans cet onglet. Connectez-vous à votre espace JD2M, puis relancez l'export.",
    );

  const bandeau = document.createElement("div");
  bandeau.style.cssText =
    "position:fixed;z-index:2147483647;top:12px;right:12px;padding:12px 16px;background:#111;color:#fff;font:14px system-ui;border-radius:8px;box-shadow:0 4px 16px #0004";
  document.body.append(bandeau);
  let appels = 0;
  let phase = "";
  const etat = (texte = phase) => {
    phase = texte;
    bandeau.textContent = `Export JD2M : ${texte} (${appels} lectures)`;
  };
  /** @type {{ url: string; http: number; message: string | null }[]} */
  const erreurs = [];

  // Every call is a GET with the session header: the export never writes to JD2M.
  /** @param {string} chemin @param {Record<string, string | number>} params @returns {Promise<any>} */
  async function lire(chemin, params = {}) {
    const query = new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)]));
    const url = `${API}${chemin}?${query}`;
    appels++;
    etat();
    const r = await fetch(url, {
      method: "GET",
      headers: { Accept: "application/json", "X-TOKEN": token },
    });
    const corps = await r.json().catch(() => null);
    if (r.status === 401 || corps?.status === -401)
      stop("Votre session JD2M a expiré. Reconnectez-vous, puis relancez l'export.");
    if (!r.ok || corps?.status !== 0) {
      erreurs.push({ url, http: r.status, message: corps?.message ?? null });
      return null;
    }
    return corps;
  }

  /**
   * Les listes paginées : JD2M ne demande la page suivante que quand une page revient pleine.
   * @param {string} chemin @param {Record<string, string | number>} params @param {number} taillePage
   */
  async function lireTout(chemin, params, taillePage) {
    /** @type {unknown[]} */
    const datas = [];
    let premiere = null;
    for (let page = 1; ; page++) {
      const r = await lire(chemin, { ...params, pageIndex: page });
      if (!r) return premiere && { ...premiere, datas };
      premiere ??= r;
      datas.push(...r.datas);
      if (!taillePage || r.datas.length < taillePage || page >= 100) return { ...premiere, datas };
    }
  }

  /** Un fichier de /res (liasse, FEC, aide 2042) en base64 : le lien meurt avec la session, le contenu non. */
  /** @param {string | null | undefined} url */
  async function fichier(url) {
    if (!url) return null;
    appels++;
    etat();
    const r = await fetch(url, { method: "GET", headers: { "X-TOKEN": token } });
    if (!r.ok) {
      erreurs.push({ url, http: r.status, message: null });
      return null;
    }
    const blob = await r.blob();
    const base64 = await new Promise((ok, ko) => {
      const fr = new FileReader();
      fr.onload = () => ok(String(fr.result).split(",")[1] ?? "");
      fr.onerror = () => ko(fr.error);
      fr.readAsDataURL(blob);
    });
    return { type: blob.type, octets: blob.size, base64 };
  }

  etat("dossier");
  const config = await lire("/config/config");
  const taillePage = config?.datas?.pageSize ?? 0;
  const activites = await lire("/client/activites");
  const choisie = Number(sessionStorage.getItem("activite"));
  const activite =
    activites?.datas?.find((/** @type {{ Oid: number }} */ a) => a.Oid === choisie) ??
    activites?.datas?.[0];
  if (!activite) stop("Aucune activité trouvée dans ce compte JD2M : rien à exporter.");
  const activiteId = activite.Oid;
  const fiscyears = await lire("/client/fiscyears", { activiteId });
  /** @type {Record<string, unknown>} */
  const dossier = { "client-activites.json": activites, "client-fiscyears.json": fiscyears };
  dossier["client-paidyears.json"] = await lire("/client/paidyears");
  for (const [classe, attribut] of [
    ["ActiviteRegimeReel", "FraisAcquisition"],
    ["ActiviteRegimeReel", "FormeJuridique"],
    ["ActiviteRegimeReel", "FinActiviteCause"],
    ["Appartement", "Classement"],
    ["Appartement", "CauseVente"],
    ["Emprunt", "EcheancesInterval"],
    ["ExploitantDetail", "SSIAffiliation"],
    ["ImmobilisationBase", "CauseSortie"],
  ])
    dossier[`enums/${classe}-${attribut}.json`] = await lire("/util/values", { classe, attribut });

  /** @type {Record<number, unknown>} */
  const annees = {};
  /** @type {{ Oid: number; AnneeFiscale: number; Liasse?: unknown }[]} */
  const exercices = (fiscyears?.datas ?? []).toSorted(
    (/** @type {{ AnneeFiscale: number }} */ a, /** @type {{ AnneeFiscale: number }} */ b) =>
      a.AnneeFiscale - b.AnneeFiscale,
  );
  for (const fy of exercices) {
    const annee = fy.AnneeFiscale;
    const anneeId = fy.Oid;
    const a = { activiteId, anneeId };
    /** @type {Record<string, any>} */
    const f = {};
    etat(`${annee}`);
    f["client-fiscyear.json"] = await lire("/client/fiscyear", a);
    f["client-activite.json"] = await lire("/client/activite", a);
    f["exploitant-list.json"] = await lire("/exploitant/list", a);
    f["exploitant-details.json"] = await lire("/exploitant/details", { anneeId });
    f["client-comptes.json"] = await lire("/client/comptes", { anneeId });
    for (const famille of [6, 7, 16])
      f[`client-articles-famille${famille}.json`] = await lire("/client/articles", {
        famille,
        anneeId,
      });
    f["logement-list.json"] = await lire("/logement/list", a);
    f["logement-immobilisations-all.json"] = await lire("/logement/immobilisations", {
      ...a,
      aptId: 0,
    });
    f["logement-usage-all.json"] = await lire("/logement/usage", { ...a, aptId: 0 });
    for (const l of f["logement-list.json"]?.datas ?? []) {
      const p = { ...a, aptId: l.Oid };
      f[`logement-${l.Oid}-composants.json`] = await lire("/logement/composants", p);
      f[`logement-${l.Oid}-immobilisations.json`] = await lire("/logement/immobilisations", p);
      f[`logement-${l.Oid}-usage.json`] = await lire("/logement/usage", p);
    }
    f["emprunt-list.json"] = await lire("/emprunt/list", a);
    for (const e of f["emprunt-list.json"]?.datas ?? [])
      f[`emprunt-${e.Oid}-echeances.json`] = await lire("/emprunt/echeances", {
        anneeId,
        empId: e.Oid,
      });
    f["depense-list.json"] = await lireTout("/depense/list", { anneeId }, taillePage);
    f["recette-list.json"] = await lireTout("/recette/list", { anneeId }, taillePage);
    f["document-list.json"] = await lire("/document/list", a);
    f["client-liasse-IMMOS.json"] = await lire("/client/liasse", { anneeId, field: "IMMOS" });
    // An open year has no liasse yet: its links are absent and the year still exports.
    const liasse = f["client-fiscyear.json"]?.datas?.Liasse ?? fy.Liasse ?? null;
    etat(`${annee}, liasse et FEC`);
    const pieces = {
      "liasse-2031-2033.pdf": await fichier(liasse?.UrlLiasse),
      "fec.txt": await fichier(liasse?.UrlFEC),
      "aide-2042-c-pro.pdf": await fichier(liasse?.Url2042CPRO),
    };
    annees[annee] = { anneeId, fichiers: f, pieces };
  }

  const bundle = {
    source: "jd2m",
    version: 1,
    exportedAt: new Date().toISOString(),
    activiteId,
    autresActivites: (activites?.datas ?? [])
      .map((/** @type {{ Oid: number }} */ x) => x.Oid)
      .filter((/** @type {number} */ oid) => oid !== activiteId),
    lectures: appels,
    erreurs,
    dossier,
    annees,
  };
  const blob = new Blob([JSON.stringify(bundle)], { type: "application/json" });
  const lien = document.createElement("a");
  lien.href = URL.createObjectURL(blob);
  lien.download = `jd2m-export-${bundle.exportedAt.slice(0, 10)}.json`;
  document.body.append(lien);
  lien.click();
  lien.remove();
  setTimeout(() => URL.revokeObjectURL(lien.href), 60_000);
  const n = Object.keys(annees).length;
  const nb = `${n} année${n > 1 ? "s" : ""}`;
  bandeau.textContent = erreurs.length
    ? `Export JD2M : ${nb}, ${erreurs.length} lectures en échec. Fichier téléchargé, à vérifier.`
    : `Export JD2M terminé : ${nb}, fichier téléchargé. Importez-le dans Locameublé.`;
  setTimeout(() => bandeau.remove(), 15_000);
  return { annees: Object.keys(annees), lectures: appels, erreurs, octets: blob.size };
})();