@icure/api 7.1.6 → 7.1.7

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

@@ -1,220 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,218 +0,0 @@
-/**
- * @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

@@ -1,122 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-}