@icure/be-fhc-api 0.4.0

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

@@ -0,0 +1,220 @@
+import { parseNumber, formatNumber, isValidNumber } 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"
+
+const nihiiRegExp = new RegExp("^(\\d{1})(\\d{5})(\\d{2})(\\d{3})$")
+const ssinRegExp = new RegExp("^(\\d{2})(\\d{2})(\\d{2})(\\d{3})(\\d{2})$")
+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)
+  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/x-api/utils/hcp-util.ts

@@ -0,0 +1,138 @@
+import * as _ from "lodash"
+import { HealthcareParty, Telecom } from "@icure/api"
+
+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/x-api/utils/insurability-util.ts

@@ -0,0 +1,57 @@
+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"),
+    _.get(patient, "insurabilities[0].parameters.tc2")
+  )
+}
+
+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
+}

package/x-api/utils/uuid-encoder.ts

@@ -0,0 +1,127 @@
+import * as bigInt from "big-integer"
+
+const knownBases: { [key: string]: string } = {
+  base64: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/",
+  base62: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", // Bitcoin base58
+  base36: "0123456789abcdefghijklmnopqrstuvwxyz",
+  base32: "0123456789abcdefghjkmnpqrstvwxyz", // Crockford's base32
+  base16: "0123456789abcdef",
+  base10: "0123456789",
+  base2: "01"
+}
+
+const caseSensitiveBases: { [key: string]: boolean } = {
+  base62: true,
+  base58: true,
+  base36: false,
+  base32: false,
+  base16: false,
+  base10: true,
+  base2: true
+}
+
+export class UuidEncoder {
+  private encStr: string = knownBases.base36
+  private isCaseSensitive: boolean = false
+  private base: number = 36
+  /**
+   * @public
+   * @param [baseEncodingStr] A string containing all usable letters for encoding
+   * @constructor
+   */
+  constructor(baseEncodingStr = "base36") {
+    this.setBaseEncodingStr(baseEncodingStr)
+  }
+
+  /**
+   * Set encoding base
+   * @param {string} baseEncodingStr A string containing all usable letters for encoding
+   * @public
+   */
+  setBaseEncodingStr(baseEncodingStr: string) {
+    this.encStr = UuidEncoder.resolveEncodingStr(baseEncodingStr)
+    this.isCaseSensitive = UuidEncoder.isCaseSensitiveBase(baseEncodingStr)
+    this.base = this.encStr.length
+  }
+
+  /**
+   * @private
+   * @param {string} baseEncodingStr
+   * @returns {string}
+   */
+  static resolveEncodingStr(baseEncodingStr: string) {
+    return Object.prototype.hasOwnProperty.call(knownBases, baseEncodingStr)
+      ? knownBases[baseEncodingStr]
+      : baseEncodingStr
+  }
+
+  /**
+   * @public
+   * @param baseEncodingStr
+   * @returns {boolean}
+   */
+  static isCaseSensitiveBase(baseEncodingStr: string) {
+    return Object.prototype.hasOwnProperty.call(caseSensitiveBases, baseEncodingStr)
+      ? caseSensitiveBases[baseEncodingStr]
+      : true
+  }
+
+  /**
+   * Encode a UUID
+   * @param {string} uuid Properly formatted UUID
+   * @returns {string} Encoded UUID
+   * @public
+   */
+  encode(uuid: string) {
+    const cleanUuid = uuid.replace(/-/g, "")
+    const { base, encStr } = this
+
+    let iUuid = bigInt(cleanUuid, 16)
+    let str = ""
+
+    do {
+      str = encStr.substr(iUuid.mod(base).valueOf(), 1) + str
+      iUuid = iUuid.divide(base)
+    } while (iUuid.greater(0))
+
+    return str
+  }
+
+  /**
+   * Decode an encoded UUID
+   * @public
+   * @param {string} str Previously encoded string
+   * @returns {string} Properly formatted UUID
+   * @throws Throws an {Error} when encountering invalid data
+   */
+  decode(str: string) {
+    let iUuid = bigInt(0)
+
+    const { base, encStr } = this
+    const len = str.length
+    const finalStr = this.isCaseSensitive ? str : str.toLowerCase()
+
+    for (let pos = 0; pos < len; pos += 1) {
+      const ch = finalStr.substr(pos, 1)
+      const encPos = encStr.indexOf(ch)
+
+      if (encPos < 0) {
+        throw new Error("Invalid encoded data")
+      }
+
+      iUuid = iUuid.add(encPos)
+
+      if (pos < len - 1) {
+        iUuid = iUuid.multiply(base)
+      }
+    }
+
+    const uuid = iUuid.toString(16).padStart(32, "0")
+
+    return `${uuid.substr(0, 8)}-${uuid.substr(8, 4)}-${uuid.substr(12, 4)}-${uuid.substr(
+      16,
+      4
+    )}-${uuid.substr(20)}`
+  }
+}