@tricoteuses/senat/lib/model/dosleg.ts

Handle French Sénat's open data

import {
  Ass, assFieldsToTrim,
  Aud, audFieldsToTrim,
  Auteur, auteurFieldsToTrim,
  DateSeance, dateSeanceFieldsToTrim,
  DecCoc, deccocFieldsToTrim,
  DenRap, denrapFieldsToTrim,
  DocAtt, docattFieldsToParseInt, docattFieldsToTrim,
  Ecr, ecrFieldsToTrim,
  EtaLoi, etaloiFieldsToTrim,
  LecAss, lecassFieldsToTrim,
  LecAssRap, lecassrapFieldsToTrim,
  Lecture, lectureFieldsToTrim,
  Loi, loiFieldsToTrim,
  Org, orgFieldsToTrim,
  OriTxt, oritxtFieldsToTrim,
  Qua, quaFieldsToTrim,
  Rap, rapFieldsToParseInt, rapFieldsToTrim,
  RapOrg, raporgFieldsToTrim,
  Scr, scrFieldsToTrim,
  Texte, texteFieldsToParseInt, texteFieldsToTrim,
  TypAtt, typattFieldsToTrim,
  TypLec, typlecFieldsToTrim,
  TypLoi, typloiFieldsToTrim,
  TypTxt, typtxtFieldsToTrim,
  TypUrl, typurlFieldsToTrim,
} from '../types/dosleg'
import { dbByName } from "../databases"
import { parseIntFields, trimFieldsRight } from '../fields'

export const getAsss = async (ids: string[]): Promise<Ass[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM ass
      WHERE codass IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((ass: Ass) => trimFieldsRight(assFieldsToTrim, ass))
}

export const getAudsFromLecassidts = async (ids: string[]): Promise<Aud[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM aud
      WHERE lecassidt IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((aud: Aud) => trimFieldsRight(audFieldsToTrim, aud))
}

export const getAuteurs = async (ids: string[]): Promise<Auteur[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM auteur
      WHERE autcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((auteur: Auteur) => trimFieldsRight(auteurFieldsToTrim, auteur))
}

export const getDatesSeancesFromLecassidts = async (
  ids: string[],
): Promise<DateSeance[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM date_seance
      WHERE lecidt IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((dateSeance: DateSeance) =>
    trimFieldsRight(dateSeanceFieldsToTrim, dateSeance),
  )
}

export const getDeccocs = async (ids: string[]): Promise<DecCoc[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM deccoc
      WHERE deccoccod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((deccoc: DecCoc) => trimFieldsRight(deccocFieldsToTrim, deccoc))
}

export const getDenraps = async (ids: string[]): Promise<DenRap[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM denrap
      WHERE coddenrap IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((denrap: DenRap) => trimFieldsRight(denrapFieldsToTrim, denrap))
}

export const getDocattsFromRapcods = async (
  ids: string[],
): Promise<DocAtt[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM docatt
      WHERE rapcod IN($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((docatt: DocAtt) =>
    parseIntFields(
      docattFieldsToParseInt,
      trimFieldsRight(docattFieldsToTrim, docatt),
    ),
  )
}

export const getEcrsFromRapcods = async (ids: string[]): Promise<Ecr[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM ecr
      WHERE rapcod IN($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((ecr: Ecr) => trimFieldsRight(ecrFieldsToTrim, ecr))
}

export const getEcrsFromTexcods = async (ids: string[]): Promise<Ecr[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM ecr
      WHERE texcod IN($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((ecr: Ecr) => trimFieldsRight(ecrFieldsToTrim, ecr))
}

export const getEtalois = async (ids: string[]): Promise<EtaLoi[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM etaloi
      WHERE etaloicod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((etaloi: EtaLoi) => trimFieldsRight(etaloiFieldsToTrim, etaloi))
}

export const getLecasssFromLecidts = async (
  ids: string[],
): Promise<LecAss[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM lecass
      WHERE lecidt IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((lecass: LecAss) => trimFieldsRight(lecassFieldsToTrim, lecass))
}

export const getLecassrapsFromLecassidts = async (
  ids: string[],
): Promise<LecAssRap[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM lecassrap
      WHERE lecassidt IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((lecassrap: LecAssRap) =>
    trimFieldsRight(lecassrapFieldsToTrim, lecassrap),
  )
}

export const getLecturesFromLoicods = async (
  ids: string[],
): Promise<Lecture[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM lecture
      WHERE loicod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((lecture: Lecture) => trimFieldsRight(lectureFieldsToTrim, lecture))
}

export const getLois = async (ids: string[]): Promise<Loi[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM loi
      WHERE loicod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((loi: Loi) => trimFieldsRight(loiFieldsToTrim, loi))
}

export const getAllLois = async (): Promise<Loi[]> => {
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM loi
    `
    )
  ).map((loi: Loi) => trimFieldsRight(loiFieldsToTrim, loi))
}

export const getOrgs = async (ids: string[]): Promise<Org[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM org
      WHERE orgcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((org: Org) => trimFieldsRight(orgFieldsToTrim, org))
}

export const getOrgsFromRapcods = async (ids: string[]): Promise<Org[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM org
      WHERE orgcod IN (
        SELECT orgcod
        FROM raporg
        WHERE rapcod IN ($<ids:list>)
      )
    `,
      {
        ids,
      },
    )
  ).map((org: Org) => trimFieldsRight(orgFieldsToTrim, org))
}

export const getRaporgsFromOrgcods = async (ids: string[]): Promise<RapOrg[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM raporg
      WHERE orgcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((raporg: RapOrg) => trimFieldsRight(raporgFieldsToTrim, raporg))
}

export const getOritxts = async (ids: string[]): Promise<OriTxt[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM oritxt
      WHERE oritxtcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((oritxt: OriTxt) => trimFieldsRight(oritxtFieldsToTrim, oritxt))
}

export const getQuas = async (ids: string[]): Promise<Qua[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM qua
      WHERE quacod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((qua: Qua) => trimFieldsRight(quaFieldsToTrim, qua))
}

export const getRaps = async (ids: string[]): Promise<Rap[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM rap
      WHERE rapcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((rap: Rap) =>
    parseIntFields(rapFieldsToParseInt, trimFieldsRight(rapFieldsToTrim, rap)),
  )
}

export const getScrsFromCodes = async (ids: string[]): Promise<Scr[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM scr
      WHERE code IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((scr: Scr) => trimFieldsRight(scrFieldsToTrim, scr))
}

export const getTextesFromLecassidts = async (
  ids: string[],
): Promise<Texte[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM texte
      WHERE lecassidt IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((texte: Texte) =>
    parseIntFields(
      texteFieldsToParseInt,
      trimFieldsRight(texteFieldsToTrim, texte),
    ),
  )
}

export const getTypatts = async (ids: string[]): Promise<TypAtt[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM typatt
      WHERE typattcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((typatt: TypAtt) => trimFieldsRight(typattFieldsToTrim, typatt))
}

export const getTyplecs = async (ids: string[]): Promise<TypLec[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM typlec
      WHERE typleccod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((typlec: TypLec) => trimFieldsRight(typlecFieldsToTrim, typlec))
}

export const getTyplois = async (ids: string[]): Promise<TypLoi[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM typloi
      WHERE typloicod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((typloi: TypLoi) => trimFieldsRight(typloiFieldsToTrim, typloi))
}

export const getTyptxts = async (ids: string[]): Promise<TypTxt[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM typtxt
      WHERE typtxtcod IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((typtxt: TypTxt) => trimFieldsRight(typtxtFieldsToTrim, typtxt))
}

export const getTypurls = async (ids: string[]): Promise<TypUrl[]> => {
  if (ids.length === 0) {
    return []
  }
  return (
    await dbByName.dosleg.any(
      `
      SELECT *
      FROM typurl
      WHERE typurl IN ($<ids:list>)
    `,
      {
        ids,
      },
    )
  ).map((typurl: TypUrl) => trimFieldsRight(typurlFieldsToTrim, typurl))
}