@icure/api 7.1.4 → 7.1.6

package/icc-x-api/utils/formatting-util.ts

@@ -0,0 +1,220 @@
+import { parseNumber, formatNumber, isValidNumber, ParsedNumber } from 'libphonenumber-js'
+
+import * as moment from 'moment'
+import * as _ from 'lodash'
+import { Moment } from 'moment'
+
+// TODO: move this to env.js?
+const DEFAULT_COUNTRY = 'BE'
+
+export const nihiiRegExp = new RegExp('^(\\d{1})(\\d{5})(\\d{2})(\\d{3})$')
+export const ssinRegExp = new RegExp('^(\\d{2})(\\d{2})(\\d{2})(\\d{3})(\\d{2})$')
+export const ibanRegExp = new RegExp('^(\\d{4})(\\d{4})(\\d{4})(\\d{4})$')
+
+const patterns = {
+  IBAN: (iban: string) => /^BE\d{14}$/.test(iban) && isValidIBAN(iban),
+  IBANBE: (iban: string) => /^BE\d{14}$/.test(iban) && isValidIBAN(iban),
+}
+
+//http://ht5ifv.serprest.pt/extensions/tools/IBAN/
+export function isValidIBAN(iban: string) {
+  //This function check if the checksum if correct
+  iban = iban.replace(/^(.{4})(.*)$/, '$2$1') //Move the first 4 chars from left to the right
+  const fun = (e: string) => (e.charCodeAt(0) - 'A'.charCodeAt(0) + 10).toString()
+  iban = iban.replace(/[A-Z]/g, fun) //Convert A-Z to 10-25
+  let $sum = 0
+  let $ei = 1 //First exponent
+  for (let $i = iban.length - 1; $i >= 0; $i--) {
+    $sum += $ei * parseInt(iban.charAt($i), 10) //multiply the digit by it's exponent
+    $ei = ($ei * 10) % 97 //compute next base 10 exponent  in modulus 97
+  }
+  return $sum % 97 === 1
+}
+
+export function ibanValidate(iban: string) {
+  if (iban.startsWith('BE')) {
+    return patterns.IBANBE(iban)
+  } else {
+    return patterns.IBAN(iban)
+  }
+}
+
+export function ibanFormat(iban: string): string {
+  return iban.replace(ibanRegExp, '$1 $2 $3 $4')
+}
+
+export function nihiiFormat(nihii: string): string {
+  return nihii.replace(nihiiRegExp, '$1 $2 $3 $4')
+}
+
+export function nihiiValidate(nihii: string): boolean {
+  return !!nihii.match(nihiiRegExp)
+}
+
+export function ssinFormat(ssin: string): string {
+  return ssin.replace(ssinRegExp, '$1 $2 $3 $4 $5')
+}
+
+export function ssinValidate(ssin: string): boolean {
+  return !!ssin.match(ssinRegExp)
+}
+
+/* Alternate lib free version
+export function phoneNumberValidate(phoneNumber: string): boolean {
+  return (
+    !!phoneNumber.match(/(?:\+|00)([1-9][0-9]{1-2})([- /.]*([0-9]+))+/) ||
+    !!phoneNumber.match(/(0[1-9][0-9]*)([- /.]*([0-9]+))+/)
+  )
+}
+
+export function phoneNumberFormat(phoneNumber: string): string {
+  let match = phoneNumber.match(/(?:\+|00)([1-9][0-9]{1-2})([- /.]*([0-9]+))+/)
+  if (match) {
+    return `+${match[1]} ${match[2].replace(/[- /.]/g, " ")}`.replace(/  /g, " ")
+  }
+  match = phoneNumber.match(/0([1-9][0-9]*)([- /.]*([0-9]+))+/)
+  if (match) {
+    return `+32 ${match[1]} ${match[2].replace(/[- /.]/g, " ")}`.replace(/  /g, " ")
+  }
+  return phoneNumber
+}
+*/
+
+export function phoneNumberValidate(phoneNumber: string): boolean {
+  return isValidNumber(phoneNumber)
+}
+
+export function phoneNumberFormat(phoneNumber: string): string {
+  const parsedPhoneNumber = parseNumber(phoneNumber, DEFAULT_COUNTRY) as ParsedNumber
+  if (_.isEmpty(parsedPhoneNumber)) {
+    // The number is not valid, so we leave the input string as-is.
+    return phoneNumber
+  }
+  return formatNumber(parsedPhoneNumber, 'INTERNATIONAL')
+}
+
+/**
+ * Converts a backend date number (e.g., patient birth date) into a Date object.
+ * @param dateNumber a YYYYMMDD date number from the backend
+ * @return a Date object
+ * @throws Error if it is impossible to create a date from the number, other if dateNumber is negative.
+ * @see #dateEncode
+ * @see #timeDecode
+ */
+export function dateDecode(dateNumber: number): Date | undefined {
+  if (!dateNumber) {
+    return undefined
+  }
+
+  if (dateNumber < 0) {
+    throw new Error("We don't decode negative dates. Please make sure you have valid data.")
+  }
+  const dateNumberStr: string = _.padStart(dateNumber.toString(), 8, '19700101')
+  if (dateNumberStr.length > 8) {
+    if (dateNumberStr.endsWith('000000')) {
+      return dateNumber ? moment(dateNumberStr, 'YYYYMMDD000000').toDate() : undefined
+    }
+
+    throw Error("Decoded date is over year 9999. We can't format it properly.")
+  }
+  return dateNumber ? moment(dateNumberStr, 'YYYYMMDD').toDate() : undefined
+}
+
+/**
+ * Converts a backend time number (e.g., health element openingDate) into a Date object.
+ * @param timeNumber a YYYYMMDD date number from the backend
+ * @return a Date object
+ * @see #timeEncode
+ * @see #dateDecode
+ */
+export function timeDecode(timeNumber: number): Date | undefined {
+  return timeNumber ? moment(timeNumber.toString(), 'YYYYMMDDHHmmss').toDate() : undefined
+}
+
+/**
+ * Encodes a Date object into a backend date number (e.g., patient birth date).
+ * @param date a Date object
+ * @return a YYYYMMDD date number for the backend
+ * @see #dateDecode
+ * @see #timeEncode
+ */
+export function dateEncode(date: Date): number | undefined {
+  const dateStr = _.padStart(moment(date).format('YYYYMMDD'), 8, '19700101')
+  // date is null if the field is not set
+  return date ? Number(dateStr) : undefined
+}
+
+/**
+ * Encodes a Date object into a backend time number (e.g., health element openingDate).
+ * @param date a Date object
+ * @return a YYYYMMDDHHmmss date number for the backend
+ * @see #timeDecode
+ * @see #dateEncode
+ */
+export function timeEncode(date: Date): number | undefined {
+  return date ? Number(moment(date).format('YYYYMMDDHHmmss')) : undefined
+}
+
+/**
+ * Formats a value and a physical unit into text.
+ * @param value the numerical or string value to encode
+ * @param unit the unit represented as a string (an empty string is also supported)
+ */
+export function unit(value: number | string, unit: string | null): string {
+  unit = unit || ''
+  let separator: string
+  if (!unit || unit.startsWith('°')) {
+    separator = ''
+  } else {
+    // including '%'
+    separator = '\xa0'
+  }
+  return value + separator + unit
+}
+
+/**
+ * 0.1 + 0.2 = 0.30000000000000004. Use this function to be better at maths.
+ * @param a number
+ * @return the rounded number, two after the comma
+ */
+export function amount(value: number): number {
+  return Number((value || 0).toFixed(2))
+}
+
+/**
+ * A simple formatter to keep the logic across the app.
+ * Input: 2.1 ; Output: 2.10€
+ */
+export function money(value: number): string {
+  return [(value || 0).toFixed(2), '€'].join('')
+}
+
+/**
+ * Transform a dictionary to a url params.
+ * From { key1: value1, key2: value2, ... } returns key1=value1&key2=value2&...=...
+ */
+export function toUrlParams(params: { [key: string]: string }): string {
+  return _.filter(_.map(params, (value, key) => (value ? key + '=' + value : undefined))).join('&')
+}
+
+export function personName(person: { firstName?: string; lastName?: string }): string {
+  return `${person.firstName || ''} ${person.lastName || ''}`.trim()
+}
+
+export function personNameAbbrev(person: { firstName?: string; lastName?: string }): string {
+  const firstName = person.firstName ? person.firstName[0] + '.' : undefined
+  return personName({ ...person, firstName })
+}
+
+export function toMoment(epochOrLongCalendar: number): Moment | null {
+  if (!epochOrLongCalendar && epochOrLongCalendar !== 0) {
+    return null
+  }
+  if (epochOrLongCalendar >= 18000101 && epochOrLongCalendar < 25400000) {
+    return moment('' + epochOrLongCalendar, 'YYYYMMDD')
+  } else if (epochOrLongCalendar >= 18000101000000) {
+    return moment('' + epochOrLongCalendar, 'YYYYMMDDhhmmss')
+  } else {
+    return moment(epochOrLongCalendar)
+  }
+}

package/icc-x-api/utils/functional-util.ts

@@ -0,0 +1,16 @@
+export function also<T>(value: T, lambda: (it: T) => void) {
+  lambda(value)
+  return value
+}
+
+export function fold<T, R>(whereToFold: Array<T>, initial: R, operation: (acc: R, element: T) => R): R {
+  let accumulator = initial
+  for (let i = 0; i < whereToFold.length; i++) accumulator = operation(accumulator, whereToFold[i])
+  return accumulator
+}
+
+export async function foldAsync<T, R>(whereToFold: Array<T>, initial: R, operation: (acc: R, element: T) => Promise<R>): Promise<R> {
+  let accumulator = initial
+  for (let i = 0; i < whereToFold.length; i++) accumulator = await operation(accumulator, whereToFold[i])
+  return accumulator
+}

package/icc-x-api/utils/graph-utils.ts

@@ -0,0 +1,218 @@
+/**
+ * @internal
+ * Represents a graph. Each node is associated to a set of nodes that can be directly reached from it in a single step.
+ */
+export type Graph = { [node: string]: Set<string> }
+
+/**
+ * @internal
+ * Represents from which all cycles have been removed using strongly connected components. Also holds information on all groups.
+ */
+export type StronglyConnectedGraph = {
+  acyclicGraph: Graph
+  originalLabelToAcyclicLabel: { [originalLabel: string]: string }
+  acyclicLabelToGroup: { [newLabel: string]: string[] } // includes new label.
+}
+
+/**
+ * @internal
+ * Creates a graph from a series of edges and optionally additional nodes.
+ * @param edges edges between nodes, [from, to].
+ * @param additionalNodes nodes which do not appear in any edge.
+ * @return a graph built using the provided parameters.
+ */
+export function graphFromEdges(edges: [string, string][], additionalNodes?: string[]): Graph {
+  const nodes = edges.reduce<Set<string>>((acc, [edgeFrom, edgeTo]) => {
+    acc.add(edgeFrom)
+    acc.add(edgeTo)
+    return acc
+  }, new Set(additionalNodes ?? []))
+  const res = Array.from(nodes).reduce<Graph>((res, node) => {
+    res[node] = new Set<string>()
+    return res
+  }, {})
+  edges.forEach(([edgeFrom, edgeTo]) => {
+    if (edgeFrom != edgeTo) {
+      res[edgeFrom].add(edgeTo)
+    }
+  })
+  return res
+}
+
+/**
+ * @internal
+ * Get the nodes reachable from each node in an acyclic graph. Exclude the node itself.
+ * @param graph an acyclic graph.
+ * @return all nodes reachable from each node in the graph with 1 or more steps.
+ */
+export function reachSetsAcyclic(graph: Graph): { [node: string]: Set<string> } {
+  const res: { [node: string]: Set<string> } = {}
+  function calculateAndCacheReachSetRecursive(node: string): Set<string> {
+    if (res[node]) return res[node]
+    const set = new Set(Array.from(graph[node]))
+    graph[node].forEach((child) => {
+      calculateAndCacheReachSetRecursive(child).forEach((x) => set.add(x))
+    })
+    res[node] = set
+    return set
+  }
+  Object.keys(graph).forEach((n) => calculateAndCacheReachSetRecursive(n))
+  return res
+}
+
+/**
+ * @internal
+ * Get a new graph where each cycle has been replaced by a single node, with label chosen from the labels of nodes in the cycle (the specific way
+ * the label is chosen is implementation-dependant).
+ * @param graph a graph.
+ * @return the new graph and dictionaries to allow mapping between original labels and labels in the new graph
+ */
+export function acyclic(graph: Graph): StronglyConnectedGraph {
+  const idToName = Object.keys(graph)
+  const nameToId: { [name: string]: number } = {}
+  idToName.forEach((name, id) => {
+    nameToId[name] = id
+  })
+  const ogAdjacency: number[][] = idToName.map((name) => {
+    return Array.from(graph[name]).map((adjacencyName) => nameToId[adjacencyName])
+  })
+  const { components, adjacencyList } = stronglyConnectedComponents(ogAdjacency)
+  const namedGroups = components.map((group) => group.map((id) => idToName[id]))
+  const originalLabelToAcyclicLabel: { [originalLabel: string]: string } = {}
+  namedGroups.forEach((group) => {
+    group.forEach((element) => {
+      originalLabelToAcyclicLabel[element] = group[0]
+    })
+  })
+  const acyclicLabelToGroup: { [newLabel: string]: string[] } = {}
+  namedGroups.forEach((group) => {
+    acyclicLabelToGroup[group[0]] = group
+  })
+  const remappedIdToName = components.map((group) => idToName[group[0]])
+  const res: Graph = {}
+  adjacencyList.forEach((adjacencyList, index) => {
+    res[remappedIdToName[index]] = new Set(adjacencyList.filter((x) => x !== index).map((x) => remappedIdToName[x]))
+  })
+  return { acyclicGraph: res, originalLabelToAcyclicLabel, acyclicLabelToGroup }
+}
+
+// Implementation from https://github.com/mikolalysenko/strongly-connected-components
+function stronglyConnectedComponents(adjList: number[][]): { components: number[][]; adjacencyList: number[][] } {
+  const numVertices = adjList.length
+  const index = new Array(numVertices)
+  const lowValue = new Array(numVertices)
+  const active = new Array(numVertices)
+  const child = new Array(numVertices)
+  const scc = new Array(numVertices)
+  const sccLinks = new Array(numVertices)
+
+  //Initialize tables
+  for (let i = 0; i < numVertices; ++i) {
+    index[i] = -1
+    lowValue[i] = 0
+    active[i] = false
+    child[i] = 0
+    scc[i] = -1
+    sccLinks[i] = []
+  }
+
+  // The strongConnect function
+  let count = 0
+  const components: number[][] = []
+  const sccAdjList: number[][] = []
+
+  function strongConnect(v: number) {
+    // To avoid running out of stack space, this emulates the recursive behaviour of the normal algorithm, effectively using T as the call stack.
+    const S = [v],
+      T = [v]
+    index[v] = lowValue[v] = count
+    active[v] = true
+    count += 1
+    while (T.length > 0) {
+      v = T[T.length - 1]
+      const e = adjList[v]
+      if (child[v] < e.length) {
+        // If we're not done iterating over the children, first try finishing that.
+        let i
+        for (i = child[v]; i < e.length; ++i) {
+          // Start where we left off.
+          const u = e[i]
+          if (index[u] < 0) {
+            index[u] = lowValue[u] = count
+            active[u] = true
+            count += 1
+            S.push(u)
+            T.push(u)
+            break // First recurse, then continue here (with the same child!).
+            // There is a slight change to Tarjan's algorithm here.
+            // Normally, after having recursed, we set lowValue like we do for an active child (although some variants of the algorithm do it slightly differently).
+            // Here, we only do so if the child we recursed on is still active.
+            // The reasoning is that if it is no longer active, it must have had a lowValue equal to its own index, which means that it is necessarily higher than our lowValue.
+          } else if (active[u]) {
+            lowValue[v] = Math.min(lowValue[v], lowValue[u]) | 0
+          }
+          if (scc[u] >= 0) {
+            // Node v is not yet assigned an scc, but once it is that scc can apparently reach scc[u].
+            sccLinks[v].push(scc[u])
+          }
+        }
+        child[v] = i // Remember where we left off.
+      } else {
+        // If we're done iterating over the children, check whether we have an scc.
+        if (lowValue[v] === index[v]) {
+          // NOTTODO: It /might/ be true that T is always a prefix of S (at this point!!!), and if so, this could be used here.
+          const component = []
+          const links = []
+          let linkCount = 0
+          for (let i = S.length - 1; i >= 0; --i) {
+            const w = S[i]
+            active[w] = false
+            component.push(w)
+            links.push(sccLinks[w])
+            linkCount += sccLinks[w].length
+            scc[w] = components.length
+            if (w === v) {
+              S.length = i
+              break
+            }
+          }
+          components.push(component)
+          const allLinks = new Array(linkCount)
+          for (let i = 0; i < links.length; i++) {
+            for (let j = 0; j < links[i].length; j++) {
+              allLinks[--linkCount] = links[i][j]
+            }
+          }
+          sccAdjList.push(allLinks)
+        }
+        T.pop() // Now we're finished exploring this particular node (normally corresponds to the return statement)
+      }
+    }
+  }
+
+  //Run strong connect starting from each vertex
+  for (let i = 0; i < numVertices; ++i) {
+    if (index[i] < 0) {
+      strongConnect(i)
+    }
+  }
+
+  // Compact sccAdjList
+  let newE
+  for (let i = 0; i < sccAdjList.length; i++) {
+    const e = sccAdjList[i]
+    if (e.length === 0) continue
+    e.sort(function (a, b) {
+      return a - b
+    })
+    newE = [e[0]]
+    for (let j = 1; j < e.length; j++) {
+      if (e[j] !== e[j - 1]) {
+        newE.push(e[j])
+      }
+    }
+    sccAdjList[i] = newE
+  }
+
+  return { components: components, adjacencyList: sccAdjList }
+}

package/icc-x-api/utils/hcp-util.ts

@@ -0,0 +1,122 @@
+import * as _ from 'lodash'
+import { HealthcareParty, Telecom } from '../../icc-api/model/models'
+
+export interface KendoDropdownSpeciality {
+  text: string
+  value: string
+}
+
+export const SPECIALITIES: Array<string> = [
+  'ADMINISTRATION',
+  'CARE_GIVER',
+  'ANATOMOPATHOLOGY',
+  'ANESTHESIOLOGY',
+  'SOCIAL_WORKER',
+  'PHARMA_ASSISTANT',
+  'AUDIOLOGIST',
+  'BACTERIOLOGY',
+  'TRUSS_ORTHOTIST',
+  'CLINICAL_BIOLOGY',
+  'CARDIOLOGY',
+  'GENERAL_SURGERY',
+  'MAXILLOFACIAL_SURGERY',
+  'PLASTIC_SURGERY',
+  'STOMATOLOGICAL_SURGERY',
+  'CARDIOVASCULAR_SURGERY',
+  'DENTISTRY',
+  'DERMATOLOGY',
+  'DIETETIC',
+  'ENDOCRINOLOGY',
+  'OCCUPATIONAL_THERAPIST',
+  'GASTROENTEROLOGY',
+  'GENETIC',
+  'GERIATRICS',
+  'GYNECOLOGY',
+  'HEMATOLOGY',
+  'NURSE',
+  'NURSE_EDUCATOR',
+  'PHYSIOTHERAPY',
+  'SPEECH',
+  'ACUTE_MEDICINE',
+  'GENERAL_MEDICINE',
+  'INTERNAL_MEDICINE',
+  'NUCLEAR_MEDICINE',
+  'PHYSICAL_MEDICINE',
+  'NEONATOLOGY',
+  'NEPHROLOGY',
+  'NEUROSURGERY',
+  'NEUROLOGY',
+  'NEUROPEDIATRICS',
+  'NEUROPSYCHIATRY',
+  'NUTRITIONIST',
+  'ONCOLOGY',
+  'OPHTHALMOLOGY',
+  'ORTHOPEDICS',
+  'ORTHOPTISTE',
+  'OTORHINOLARYNGOLOGY',
+  'PEDIATRICS',
+  'PHARMACOLOGY',
+  'RESPIRATORY',
+  'PODIATRIST',
+  'PUBLIC_HEALTH_PREVENTION',
+  'PROSTHETIST',
+  'PSYCHIATRY',
+  'MEDICAL_PSYCHOLOGY',
+  'RADIODIAGNOSTICS',
+  'RADIOTHERAPY',
+  'RESUSCITATION',
+  'RHEUMATOLOGY',
+  'MIDWIFE',
+  'STOMATOLOGY',
+  'EMERGENCY',
+  'UROLOGY',
+  'TOXICOLOGY',
+  'TRANSPORT',
+]
+
+/**
+ * Translation keys for specialities.
+ * @see SPECIALITIES
+ */
+export const SPECIALITIES_KEYS: { [spec: string]: string } = _.fromPairs(SPECIALITIES.map((spec) => [spec, 'hcp-form.SPECIALITIES.' + spec]))
+
+export function isDoctor(nihii: string): boolean {
+  return !!nihii && nihii.length === 11 && nihii.startsWith('1') && !nihii.endsWith('005') && !nihii.endsWith('006')
+}
+
+export function isDoctorAssistant(nihii: string): boolean {
+  return !!nihii && nihii.length === 11 && nihii.startsWith('1') && nihii.endsWith('005') && nihii.endsWith('006')
+}
+
+export function getPhoneNumber(hcp: HealthcareParty, maxLength: number | undefined): number | null {
+  const phoneNumbers = (hcp.addresses || []).map((a) => {
+    const t = (a.telecoms || []).find(
+      (t: Telecom) => t.telecomType === Telecom.TelecomTypeEnum.Phone.toString() || t.telecomType === Telecom.TelecomTypeEnum.Mobile.toString()
+    )
+    let res = t && t.telecomNumber
+    if (res && maxLength) {
+      while (res.length > maxLength) {
+        if (res.startsWith('0032')) {
+          res = '0' + res.substr(4)
+        } else if (res.startsWith('+32')) {
+          res = '0' + res.substr(3)
+        } else if (res.startsWith('32')) {
+          res = '0' + res.substr(2)
+        } else if (res.startsWith('00')) {
+          res = res.substr(2)
+        } else if (res.startsWith('0')) {
+          res = res.substr(1)
+        } else if (res.startsWith('352')) {
+          res = '0' + res.substr(3)
+        } else if (res.startsWith('33')) {
+          res = '0' + res.substr(2)
+        } else {
+          res = res.substr(1)
+        }
+      }
+    }
+    return res && Number(res)
+  })
+
+  return (!phoneNumbers.length || _.isNaN(phoneNumbers[0]) ? null : phoneNumbers[0]) || null
+}

package/icc-x-api/utils/index.ts

@@ -0,0 +1,8 @@
+export * from './code-util'
+export * from './net-utils'
+export * from './crypto-utils'
+export * from './formatting-util'
+export * from './binary-utils'
+export * from './hcp-util'
+export * from './functional-util'
+export * from './websocket'

package/icc-x-api/utils/insurability-util.ts

@@ -0,0 +1,54 @@
+import * as _ from 'lodash'
+import { Patient, Insurability } from '../../icc-api/model/models'
+
+export function isBIM(ct1: number | string, ct2: number | string): boolean {
+  //BIM if ct1 ood and ct2 ood
+  return +ct1 % 2 !== 0 && +ct2 % 2 !== 0
+}
+
+export function patientIsBIM(patient: Patient) {
+  // FIXME this doesn't check the date of the insurability. It is related to the idea of having only on insurability at a time.
+  return isBIM(_.get(patient, 'insurabilities[0].parameters.tc1') ?? '000', _.get(patient, 'insurabilities[0].parameters.tc2') ?? '000')
+}
+
+export function isPatientPaymentByIo(patient: Patient) {
+  const paymentByIo = _.get(patient, 'insurabilities[0].parameters.paymentByIo')
+  return paymentByIo === 'true'
+}
+
+/**
+ * Returns the titulary id from patient insurability
+ * @throws error if the patient has no insurability data
+ * @param patient The patient
+ */
+export function getMembership(patient: Patient): string {
+  const ioCode = _.get(patient, 'insurabilities[0].identificationNumber')
+  if (_.isUndefined(ioCode)) {
+    // TODO translate
+    throw new Error("Le patient n'a pas de données d'assurabilité")
+  }
+  return ioCode
+}
+
+/**
+ * Returns the insurability from patient
+ * @throws error if the patient has no insurability data
+ * @param patient The patient
+ */
+export function getInsurability(patient: Patient): Insurability {
+  const insurability = _.get(patient, 'insurabilities[0]')
+  if (_.isUndefined(insurability)) {
+    // TODO translate
+    throw new Error("Le patient n'a pas de données d'assurabilité")
+  }
+  return insurability
+}
+
+/**
+ * Returns the insurability from patient
+ * @throws error if the patient has no insurability data
+ * @param patient
+ */
+export function isPatientHospitalized(patient: Patient): boolean {
+  return getInsurability(patient).hospitalisation || false
+}