@tricoteuses/senat 1.1.1 → 1.3.1

package/lib/model/sens.ts

@@ -1,18 +1,516 @@
-import {
-  Sen, senFieldsToParseInt, senFieldsToTrim,
-} from '../types/sens'
-import { dbByName } from "../databases"
-import { parseIntFields, trimFieldsRight } from '../fields'
-
-export const getAllSens = async (): Promise<Sen[]> => {
-  return (
-    await dbByName.sens.any(
-      `
-      SELECT *
-      FROM sen
-    `
-    )
-  ).map((sen: Sen) =>
-    parseIntFields(senFieldsToParseInt, trimFieldsRight(senFieldsToTrim, sen)),
+import { Expression, InferResult } from "kysely"
+import { jsonArrayFrom, jsonObjectFrom } from "kysely/helpers/postgres"
+import { dbSens } from "../databases"
+import { concat, rtrim, toDateString } from "./util"
+
+function circonscription (dptNum: Expression<string>) {
+  return jsonObjectFrom(
+    dbSens.selectFrom("dpt")
+      .leftJoin("reg", "dpt.regcod", "reg.regcod")
+      .where("dpt.dptnum", "=", dptNum)
+      .select([
+        "dpt.dptcod as code",
+        "dpt.dptlib as libelle_departement",
+        "reg.reglib as libelle_region",
+      ]),
+  )
+}
+
+function textes (actId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("activite_loi")
+      .where("actid", "=", actId)
+      .select(({ ref }) => [
+        rtrim(ref("loicod")).as("loicod"),
+      ]),
+  )
+}
+
+function delegations (actId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("activite_delegation")
+      .where("actid", "=", actId)
+      .orderBy("delegidx asc"),
+  )
+}
+
+function activites (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("activite")
+      .leftJoin("activite_participant", "activite.actid", "activite_participant.actid")
+      .leftJoin("type_activite", "activite.typactcod", "type_activite.typactcod")
+      .leftJoin("categorie_activite", "activite.catactcod", "categorie_activite.catactcod")
+      .where("activite_participant.senmat", "=", senMat)
+      .select(({ ref }) => [
+        delegations(ref("activite.actid")).as("delegations"),
+        textes(ref("activite.actid")).as("textes"),
+      ])
+      .orderBy("activite.datdeb desc"),
+  )
+}
+
+function activitesPerso (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("activite_senateur")
+      .leftJoin("type_activite_senateur", "activite_senateur.typactsencod", "type_activite_senateur.typactsencod")
+      .where("activite_senateur.senmat", "=", senMat)
+      .orderBy("activite_senateur.datdeb desc"),
+  )
+}
+
+function fonctionsBureau (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("senbur")
+      .leftJoin("bur", "senbur.burcod", "bur.burcod")
+      .where("senbur.senmat", "=", senMat)
+      .select(({ ref }) => [
+        toDateString(ref("senbur.senburdatdeb")).as("date_debut"),
+        toDateString(ref("senbur.senburdatfin")).as("date_fin"),
+        "bur.burlib as libelle",
+      ])
+      .orderBy("senbur.senburdatdeb desc"),
+  )
+}
+
+function mandatsEluConseillerGeneral (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("elucan")
+      .leftJoin("typman", "elucan.typmancod", "typman.typmancod")
+      .where("elucan.senmat", "=", senMat)
+      .select(({ ref }) => [
+        circonscription(ref("elucan.dptnum").$notNull()).as("circonscription"),
+      ])
+      .orderBy("elucan.eludatdeb desc"),
+  )
+}
+
+function mandatsEluDepute (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("eludep")
+      .leftJoin("typman", "eludep.typmancod", "typman.typmancod")
+      .where("eludep.senmat", "=", senMat)
+      .select(({ ref }) => [
+        circonscription(ref("eludep.circo").$notNull()).as("circonscription"),
+      ])
+      .orderBy("eludep.eludatdeb desc"),
+  )
+}
+
+function mandatsEluDivers (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("eludiv")
+      .leftJoin("typman", "eludiv.typmancod", "typman.typmancod")
+      .where("eludiv.senmat", "=", senMat)
+      .orderBy("eludiv.eludatdeb desc"),
+  )
+}
+
+function mandatsEluEuropeen (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("elueur")
+      .leftJoin("nation", "elueur.nationcod", "nation.nationcod")
+      .leftJoin("typman", "elueur.typmancod", "typman.typmancod")
+      .where("elueur.senmat", "=", senMat)
+      .orderBy("elueur.eludatdeb desc"),
+  )
+}
+
+function mandatsEluConseillerRegional (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("elureg")
+      .leftJoin("reg", "elureg.regcod", "reg.regcod")
+      .leftJoin("typman", "elureg.typmancod", "typman.typmancod")
+      .where("elureg.senmat", "=", senMat)
+      .orderBy("elureg.eludatdeb desc"),
+  )
+}
+
+function mandatsEluSenateur (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("elusen")
+      .leftJoin("etadebman", "elusen.etadebmancod", "etadebman.etadebmancod")
+      .leftJoin("etafinman", "elusen.etafinmancod", "etafinman.etafinmancod")
+      .leftJoin("typman", "elusen.typmancod", "typman.typmancod")
+      .where("elusen.senmat", "=", senMat)
+      .select(({ ref }) => [
+        "elusen.dptnum as code_circonscription",
+        toDateString(ref("elusen.eludatdeb")).as("date_debut"),
+        toDateString(ref("elusen.eludatfin")).as("date_fin"),
+        "etadebman.etadebmanlib as etat_debut",
+        "etafinman.etafinman as etat_fin",
+      ])
+      .orderBy("elusen.eludatdeb desc"),
+  )
+}
+
+function mandatsEluTerritorial (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("eluter")
+      .leftJoin("asster", "eluter.asstercod", "asster.asstercod")
+      .leftJoin("typman", "eluter.typmancod", "typman.typmancod")
+      .where("eluter.senmat", "=", senMat)
+      .orderBy("eluter.eludatdeb desc"),
+  )
+}
+
+function mandatsEluConseillerMunicipal (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("eluvil")
+      .leftJoin("typman", "eluvil.typmancod", "typman.typmancod")
+      .where("eluvil.senmat", "=", senMat)
+      .orderBy("eluvil.eludatdeb desc"),
+  )
+}
+
+function fonctionsMembreCommission (memComId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("fonmemcom")
+      .leftJoin("foncom", "fonmemcom.foncomcod", "foncom.foncomcod")
+      .where("fonmemcom.memcomid", "=", memComId)
+      .select(({ ref }) => [
+        toDateString(ref("fonmemcom.fonmemcomdatdeb")).as("date_debut"),
+        toDateString(ref("fonmemcom.fonmemcomdatfin")).as("date_fin"),
+        "foncom.foncomlib as libelle",
+      ])
+      .orderBy("fonmemcom.fonmemcomdatdeb desc"),
+  )
+}
+
+function mandatsMembreCommission (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memcom")
+      .leftJoin("com", "memcom.orgcod", "com.orgcod")
+      .leftJoin("typorg", "com.typorgcod", "typorg.typorgcod")
+      .where("memcom.senmat", "=", senMat)
+      .select(({ ref }) => [
+        "com.typorgcod as type_code_organisme",
+        "memcom.orgcod as code_organisme",
+        "typorg.typorglib as type_organisme",
+        "com.comlilmin as libelle",
+        toDateString(ref("memcom.memcomdatdeb")).as("date_debut"),
+        toDateString(ref("memcom.memcomdatfin")).as("date_fin"),
+      ])
+      .select(({ ref }) => [
+        fonctionsMembreCommission(ref("memcom.memcomid")).as("fonctions"),
+      ])
+      .orderBy("memcom.memcomdatdeb desc"),
+  )
+}
+
+function fonctionsMembreDelegation (memDelegaId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("fonmemdelega")
+      .leftJoin("fondelega", "fonmemdelega.fondelcod", "fondelega.fondelcod")
+      .where("fonmemdelega.memdelegaid", "=", memDelegaId)
+      .select(({ ref }) => [
+        toDateString(ref("fonmemdelega.fonmemdeldatdeb")).as("date_debut"),
+        toDateString(ref("fonmemdelega.fonmemdeldatfin")).as("date_fin"),
+        "fondelega.fondellib as libelle",
+      ])
+      .orderBy("fonmemdelega.fonmemdeldatdeb desc"),
+  )
+}
+
+function mandatsMembreDelegation (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memdelega")
+      .leftJoin("delega", "memdelega.orgcod", "delega.orgcod")
+      .leftJoin("designorg", "memdelega.designcod", "designorg.designcod")
+      .leftJoin("typorg", "delega.typorgcod", "typorg.typorgcod")
+      .where("memdelega.senmat", "=", senMat)
+      .select(({ ref }) => [
+        "delega.typorgcod as type_code_organisme",
+        "memdelega.orgcod as code_organisme",
+        "typorg.typorglib as type_organisme",
+        "delega.evelib as libelle",
+        toDateString(ref("memdelega.memdelegadatdeb")).as("date_debut"),
+        toDateString(ref("memdelega.memdelegadatfin")).as("date_fin"),
+      ])
+      .select(({ ref }) => [
+        fonctionsMembreDelegation(ref("memdelega.memdelegaid")).as("fonctions"),
+      ])
+      .orderBy("memdelega.memdelegadatdeb desc"),
+  )
+}
+
+function mandatsMembreExtraParlementaire (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memextpar")
+      .leftJoin("orgext", "memextpar.orgcod", "orgext.orgcod")
+      .leftJoin("design", "memextpar.designcod", "design.designcod")
+      .where("memextpar.senmat", "=", senMat)
+      .orderBy("memextpar.memextpardatdeb desc"),
+  )
+}
+
+function fonctionsMembreGroupePolitique (memGrpPolId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("fonmemgrppol")
+      .leftJoin("fongrppol", "fonmemgrppol.fongrppolcod", "fongrppol.fongrppolcod")
+      .where("fonmemgrppol.memgrppolid", "=", memGrpPolId)
+      .select(({ ref }) => [
+        toDateString(ref("fonmemgrppol.fonmemgrppoldatdeb")).as("date_debut"),
+        toDateString(ref("fonmemgrppol.fonmemgrppoldatfin")).as("date_fin"),
+        "fongrppol.fongrppollib as libelle",
+      ])
+      .orderBy("fonmemgrppol.fonmemgrppoldatdeb desc"),
+  )
+}
+
+function mandatsMembreGroupePolitique (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memgrppol")
+      .leftJoin("grppol", "memgrppol.grppolcod", "grppol.grppolcod")
+      .leftJoin("typapppol", "memgrppol.typapppolcod", "typapppol.typapppolcod")
+      .where("memgrppol.senmat", "=", senMat)
+      .select(({ ref }) => [
+        "memgrppol.grppolcod as code",
+        "grppol.grppollibcou as libelle",
+        toDateString(ref("memgrppol.memgrppoldatdeb")).as("date_debut"),
+        toDateString(ref("memgrppol.memgrppoldatfin")).as("date_fin"),
+        "typapppol.typapppollib as fonction",
+      ])
+      .select(({ ref }) => [
+        fonctionsMembreGroupePolitique(ref("memgrppol.memgrppolid")).as("fonctions"),
+      ])
+      .orderBy("memgrppol.memgrppoldatdeb desc"),
+  )
+}
+
+function fonctionsMembreGroupeSenatorial (memGrpSenId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("fonmemgrpsen")
+      .leftJoin("fongrpsen", "fonmemgrpsen.fongrpsencod", "fongrpsen.fongrpsencod")
+      .where("fonmemgrpsen.memgrpsenid", "=", memGrpSenId)
+      .orderBy("fonmemgrpsen.fonmemgrpsendatdeb desc"),
+  )
+}
+
+function mandatsMembreGroupeSenatorial (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memgrpsen")
+      .leftJoin("grpsenami", "memgrpsen.orgcod", "grpsenami.orgcod")
+      .leftJoin("typgrpsen", "grpsenami.typgrpsencod", "typgrpsen.typgrpsencod")
+      .where("memgrpsen.senmat", "=", senMat)
+      .select(({ ref }) => [
+        fonctionsMembreGroupeSenatorial(ref("memgrpsen.memgrpsenid")).as("fonctions"),
+      ])
+      .orderBy("memgrpsen.memgrpsendatent desc"),
+  )
+}
+
+function fonctionsMembreOrganisme (memOrgId: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("fonmemorg")
+      .leftJoin("fonorg", "fonmemorg.fonorgcod", "fonorg.fonorgcod")
+      .where("fonmemorg.memorgid", "=", memOrgId)
+      .orderBy("fonmemorg.fonmemorgdatdeb desc"),
   )
 }
+
+function mandatsMembreOrganisme (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("memorg")
+      .leftJoin("org", "memorg.orgcod", "org.orgcod")
+      .leftJoin("typorg", "org.typorgcod", "typorg.typorgcod")
+      .leftJoin("designorg", "memorg.designcod", "designorg.designcod")
+      .where("memorg.senmat", "=", senMat)
+      .select(({ ref }) => [
+        fonctionsMembreOrganisme(ref("memorg.memorgid")).as("fonctions"),
+      ])
+      .orderBy("memorg.memorgdatdeb desc"),
+  )
+}
+
+function mandatsMinistre (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("minind")
+      .where("minind.senmat", "=", senMat)
+      .orderBy("minind.mindatdeb desc"),
+  )
+}
+
+function contacts (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("poicon")
+      .leftJoin("adresse", "poicon.poiconid", "adresse.poiconid")
+      .leftJoin("mel", "poicon.poiconid", "mel.poiconid")
+      .leftJoin("telephone", "poicon.poiconid", "telephone.poiconid")
+      .where("poicon.senmat", "=", senMat)
+      .orderBy("poicon.poiconnumtri asc"),
+  )
+}
+
+function urls (senMat: Expression<string>) {
+  return jsonArrayFrom(
+    dbSens.selectFrom("senurl")
+      .where("senurl.senmat", "=", senMat)
+      .select([
+        "senurl.typurlcod as code_url",
+        "senurl.senurlurl as url",
+      ])
+      .orderBy("senurl.senurlnumtri asc"),
+  )
+}
+
+const findAllQuery = dbSens
+  .selectFrom("sen")
+  .leftJoin("etasen", "sen.etasencod", "etasen.etasencod")
+  .leftJoin("pcs", "sen.pcscod", "pcs.pcscod")
+  .leftJoin("pcs42", "pcs.pcs42cod", "pcs42.pcs42cod")
+  .leftJoin("pcs24", "pcs42.pcs24cod", "pcs24.pcs24cod")
+  .leftJoin("pcs8", "pcs24.pcs8cod", "pcs8.pcs8cod")
+  .leftJoin("grppol", "sen.sengrppolcodcou", "grppol.grppolcod")
+  .leftJoin("com", "sen.sencomcodcou", "com.orgcod")
+  .select(({ ref }) => [
+    "sen.senmat as matricule",
+    "sen.quacod as qualite",
+    "sen.sennomuse as nom_usuel",
+    "sen.senprenomuse as prenom_usuel",
+    "sen.etasencod as etat",
+    toDateString(ref("sen.sendatnai")).as("date_naissance"),
+    toDateString(ref("sen.sendatdec")).as("date_deces"),
+    "sen.sengrppolcodcou as code_groupe_politique",
+    "sen.sengrppolliccou as groupe_politique",
+    "sen.sencomcodcou as code_commission_permanente",
+    "com.comlilmin as commission_permanente",
+    "sen.sencirnumcou as code_circonscription",
+    "sen.sencircou as circonscription",
+    "sen.senburliccou as fonction_bureau_senat",
+    "sen.senema as courrier_electronique",
+    "pcs.pcslil as PCS_INSEE",
+    "pcs42.pcs42lib as PCS_INSEE_42",
+    "pcs24.pcs24lib as PCS_INSEE_24",
+    "pcs8.pcs8lil as PCS_INSEE_8",
+    "sen.sendespro as description_profession",
+    "sen.sennumsie as siege",
+    "sen.sendaiurl as url_hatvp",
+  ])
+  .select(({ ref }) => [
+    urls(ref("sen.senmat")).as("urls"),
+    mandatsEluSenateur(ref("sen.senmat")).as("mandats_senateur"),
+    mandatsMembreCommission(ref("sen.senmat")).as("commissions"),
+    mandatsMembreDelegation(ref("sen.senmat")).as("delegations"),
+    mandatsMembreGroupePolitique(ref("sen.senmat")).as("groupes"),
+    fonctionsBureau(ref("sen.senmat")).as("fonctions_bureau"),
+  ])
+
+const findAllCirconscriptionsQuery = dbSens
+  .selectFrom("dpt")
+  .leftJoin("reg", "dpt.regcod", "reg.regcod")
+  .select(({ ref }) => [
+    "dpt.dptnum as identifiant",
+    "dpt.dptcod as code",
+    "dpt.dptlib as libelle_departement",
+    "dpt.dptart as article",
+    "reg.reglib as libelle_region",
+    "dpt.temvalcod as etat",
+    toDateString(ref("dpt.dptdatdeb")).as("date_debut"),
+    toDateString(ref("dpt.dptdatfin")).as("date_fin"),
+    "dpt.dptnbrsen as nombre_senateurs",
+    "dpt.dpturlcmp as url",
+  ])
+
+const findAllOrganismesQuery = dbSens
+  .selectFrom((eb) => eb
+    .selectFrom("com")
+    .select([
+      "orgcod",
+      "evelic",
+      "evelib",
+      "evelil",
+      "typorgcod",
+      "orgurlsim",
+      "orgdatcre",
+      "orgdatfin",
+      "temvalcod",
+    ]).union(eb
+      .selectFrom("delega")
+      .select([
+        "orgcod",
+        "evelic",
+        "evelib",
+        "evelil",
+        "typorgcod",
+        "orgurlsim",
+        "orgdatcre",
+        "orgdatfin",
+        "temvalcod",
+      ]),
+    ).union(eb
+      .selectFrom("grppol")
+      .select([
+        "grppolcod as orgcod",
+        "grppolliccou as evelic",
+        "grppollibcou as evelib",
+        "grppollilcou as evelil",
+        "typorgcod",
+        "grppolurlsim as orgurlsim",
+        "grppoldatcre as orgdatcre",
+        "grppoldatfin as orgdatfin",
+        "temvalcod",
+      ]),
+    ).union(eb
+      .selectFrom("grpsenami")
+      .select([
+        "orgcod",
+        "evelic",
+        "evelib",
+        "evelil",
+        "typorgcod",
+        "orgurlsim",
+        "orgdatcre",
+        "orgdatfin",
+        "temvalcod",
+      ]),
+    ).union(eb
+      .selectFrom("org")
+      .select([
+        "orgcod",
+        "evelic",
+        "evelib",
+        "evelil",
+        "typorgcod",
+        "orgurlsim",
+        "orgdatcre",
+        "orgdatfin",
+        "temvalcod",
+      ]),
+    ).as("all_organismes"),
+  ).leftJoin("typorg", "all_organismes.typorgcod", "typorg.typorgcod")
+  .select(({ ref, val }) => [
+    "all_organismes.orgcod as code",
+    "all_organismes.evelic as libelle_court",
+    "all_organismes.evelib as libelle",
+    rtrim(ref("all_organismes.evelil")).as("libelle_long"),
+    "all_organismes.typorgcod as type_code",
+    rtrim(ref("typorg.typorglib")).as("type_libelle"),
+    concat(val("https://www.senat.fr"), ref("all_organismes.orgurlsim")).as("url"),
+    toDateString(ref("all_organismes.orgdatcre")).as("date_debut"),
+    toDateString(ref("all_organismes.orgdatfin")).as("date_fin"),
+    "all_organismes.temvalcod as etat",
+  ])
+
+export type SenateurResult = InferResult<typeof findAllQuery>[0]
+export type CirconscriptionResult = InferResult<typeof findAllCirconscriptionsQuery>[0]
+export type OrganismeResult = InferResult<typeof findAllOrganismesQuery>[0]
+
+export function findAll () {
+  return findAllQuery.stream()
+}
+
+export function findAllCirconscriptions () {
+  return findAllCirconscriptionsQuery.stream()
+}
+
+export function findAllOrganismes () {
+  return findAllOrganismesQuery.stream()
+}
+
+export function findActif (): AsyncIterableIterator<{ senmat: string, sennomuse: string, senprenomuse: string }> {
+  return dbSens
+    .selectFrom("sen")
+    .where("etasencod", "=", "ACTIF")
+    .select(["senmat", "sennomuse", "senprenomuse"])
+    .stream()
+}

package/lib/model/texte.d.ts

@@ -0,0 +1,7 @@
+import { ExposeDesMotifs, FlatTexte } from "../types/texte";
+export declare function transformTexte(document: Document): FlatTexte | null;
+export declare function transformExposeDesMotifs(document: Document): ExposeDesMotifs | null;
+export declare function parseTexte(texteXml: string): FlatTexte | null;
+export declare function parseTexteFromFile(xmlFilePath: string): Promise<FlatTexte | null>;
+export declare function parseExposeDesMotifs(exposeDesMotifsHtml: string): ExposeDesMotifs | null;
+export declare function parseExposeDesMotifsFromFile(htmlFilePath: string): Promise<ExposeDesMotifs | null>;