@icure/api 5.3.6 → 5.3.8

package/icc-x-api/icc-contact-x-api.ts

@@ -1,979 +0,0 @@
-import { IccContactApi } from '../icc-api'
-import { IccCryptoXApi } from './icc-crypto-x-api'
-
-import i18n from './rsrc/contact.i18n'
-
-import * as moment from 'moment'
-import * as _ from 'lodash'
-import * as models from '../icc-api/model/models'
-import { Contact, FilterChainService, ListOfIds, Service } from '../icc-api/model/models'
-import { PaginatedListContact } from '../icc-api/model/PaginatedListContact'
-import { a2b, b2a, hex2ua, string2ua, ua2string, ua2utf8, utf8_2ua } from './utils/binary-utils'
-import { ServiceByIdsFilter } from './filters/ServiceByIdsFilter'
-import { IccDataOwnerXApi } from './icc-data-owner-x-api'
-import { truncateTrailingNulls, before } from './utils'
-import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
-
-export class IccContactXApi extends IccContactApi {
-  i18n: any = i18n
-  crypto: IccCryptoXApi
-  dataOwnerApi: IccDataOwnerXApi
-
-  constructor(
-    host: string,
-    headers: { [key: string]: string },
-    crypto: IccCryptoXApi,
-    dataOwnerApi: IccDataOwnerXApi,
-    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
-    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
-      ? window.fetch
-      : typeof self !== 'undefined'
-      ? self.fetch
-      : fetch
-  ) {
-    super(host, headers, authenticationProvider, fetchImpl)
-    this.crypto = crypto
-    this.dataOwnerApi = dataOwnerApi
-  }
-
-  newInstance(user: models.User, patient: models.Patient, c: any, confidential = false, delegates: string[] = []): Promise<models.Contact> {
-    const contact = new models.Contact(
-      _.extend(
-        {
-          id: this.crypto.randomUuid(),
-          _type: 'org.taktik.icure.entities.Contact',
-          created: new Date().getTime(),
-          modified: new Date().getTime(),
-          responsible: this.dataOwnerApi.getDataOwnerOf(user),
-          author: user.id,
-          codes: [],
-          tags: [],
-          groupId: this.crypto.randomUuid(),
-          subContacts: [],
-          services: [],
-          openingDate: parseInt(moment().format('YYYYMMDDHHmmss')),
-        },
-        c || {}
-      )
-    )
-
-    return this.initDelegationsAndEncryptionKeys(user, patient, contact, confidential, delegates)
-  }
-
-  /**
-   * 1. Extract(decrypt) the patient's secretForeignKeys from the
-   * "delegations" object.
-   * 2. Initialize & encrypt the Contact's delegations & cryptedForeignKeys.
-   * 3. Initialize & encrypt the Contact's encryptionKeys.
-   * 4. Return the contact with the extended delegations, cryptedForeignKeys
-   * & encryptionKeys.
-   */
-  private initDelegationsAndEncryptionKeys(
-    user: models.User,
-    patient: models.Patient,
-    contact: models.Contact,
-    confidential = false,
-    delegates: string[] = []
-  ): Promise<models.Contact> {
-    const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user)
-
-    return this.crypto.extractPreferredSfk(patient, dataOwnerId!, confidential).then(async (key) => {
-      if (!key) {
-        await this.crypto.reportError('Get sfk for Contact creation (confidential: ' + confidential + ')', [patient], dataOwnerId!)
-        console.error(`SFK cannot be found for Contact ${key}. The contact will not be reachable from the patient side`)
-        throw new Error("Could not find secret foreign key for patient '" + patient.id + "'")
-      }
-      const dels = await this.crypto.initObjectDelegations(contact, patient, dataOwnerId!, key ?? null)
-      const eks = await this.crypto.initEncryptionKeys(contact, dataOwnerId!)
-      _.extend(contact, {
-        delegations: dels.delegations,
-        cryptedForeignKeys: dels.cryptedForeignKeys,
-        secretForeignKeys: dels.secretForeignKeys,
-        encryptionKeys: eks.encryptionKeys,
-      })
-
-      let promise = Promise.resolve(contact)
-      _.uniq(
-        delegates.concat(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : [])
-      ).forEach(
-        (delegateId) =>
-          (promise = promise.then((contact) =>
-            this.crypto.addDelegationsAndEncryptionKeys(patient, contact, dataOwnerId!, delegateId, dels.secretId, eks.secretId).catch((e) => {
-              console.log(e)
-              return contact
-            })
-          ))
-      )
-      ;(user.autoDelegations && user.autoDelegations.anonymousMedicalInformation ? user.autoDelegations.anonymousMedicalInformation : []).forEach(
-        (delegateId) =>
-          (promise = promise.then((contact) =>
-            this.crypto.addDelegationsAndEncryptionKeys(patient, contact, dataOwnerId!, delegateId, null, eks.secretId).catch((e) => {
-              console.log(e)
-              return contact
-            })
-          ))
-      )
-      return promise
-    })
-  }
-
-  initEncryptionKeys(user: models.User, ctc: models.Contact) {
-    const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user)
-
-    return this.crypto.initEncryptionKeys(ctc, dataOwnerId!).then((eks) => {
-      let promise = Promise.resolve(
-        _.extend(ctc, {
-          encryptionKeys: eks.encryptionKeys,
-        })
-      )
-      ;(user.autoDelegations
-        ? (user.autoDelegations.all || [])
-            .concat(user.autoDelegations.medicalInformation || [])
-            .concat(user.autoDelegations.anonymousMedicalInformation || [])
-        : []
-      ).forEach(
-        (delegateId) =>
-          (promise = promise.then((contact) =>
-            this.crypto
-              .appendEncryptionKeys(contact, dataOwnerId!, delegateId, eks.secretId)
-              .then((extraEks) => {
-                return _.extend(extraEks.modifiedObject, {
-                  encryptionKeys: extraEks.encryptionKeys,
-                })
-              })
-              .catch((e) => {
-                console.log(e.message)
-                return contact
-              })
-          ))
-      )
-      return promise
-    })
-  }
-
-  /**
-   * 1. Check whether there is a delegation with 'hcpartyId' or not.
-   * 2. 'fetchHcParty[hcpartyId][1]': is encrypted AES exchange key by RSA public key of him.
-   * 3. Obtain the AES exchange key, by decrypting the previous step value with hcparty private key
-   *      3.1.  KeyPair should be fetch from cache (in jwk)
-   *      3.2.  if it doesn't exist in the cache, it has to be loaded from Browser Local store, and then import it to WebCrypto
-   * 4. Obtain the array of delegations which are delegated to his ID (hcpartyId) in this patient
-   * 5. Decrypt and collect all keys (secretForeignKeys) within delegations of previous step (with obtained AES key of step 4)
-   * 6. Do the REST call to get all contacts with (allSecretForeignKeysDelimitedByComa, hcpartyId)
-   *
-   * After these painful steps, you have the contacts of the patient.
-   *
-   * @param hcpartyId
-   * @param patient (Promise)
-   * @param usingPost
-   */
-  findBy(hcpartyId: string, patient: models.Patient, usingPost: boolean = false) {
-    return this.crypto.extractSFKsHierarchyFromDelegations(patient, hcpartyId).then((secretForeignKeys) =>
-      secretForeignKeys && secretForeignKeys.length > 0
-        ? Promise.all(
-            secretForeignKeys
-              .reduce((acc, level) => {
-                return acc.concat([
-                  {
-                    hcpartyId: level.hcpartyId,
-                    extractedKeys: level.extractedKeys.filter((key) => !acc.some((previousLevel) => previousLevel.extractedKeys.includes(key))),
-                  },
-                ])
-              }, [] as Array<{ hcpartyId: string; extractedKeys: Array<string> }>)
-              .filter((l) => l.extractedKeys.length > 0)
-              .map(({ hcpartyId, extractedKeys }) =>
-                usingPost
-                  ? this.findByHCPartyPatientSecretFKeysArray(hcpartyId, _.uniq(extractedKeys))
-                  : this.findByHCPartyPatientSecretFKeys(hcpartyId, _.uniq(extractedKeys).join(','))
-              )
-          ).then((results) => _.uniqBy(_.flatMap(results), (x) => x.id))
-        : Promise.resolve([])
-    )
-  }
-
-  async findByPatientSFKs(hcpartyId: string, patients: Array<models.Patient>): Promise<Array<models.Contact>> {
-    const perHcpId: { [key: string]: string[] } = {}
-    for (const patient of patients) {
-      ;(await this.crypto.extractSFKsHierarchyFromDelegations(patient, hcpartyId))
-        .reduce((acc, level) => {
-          return acc.concat([
-            {
-              hcpartyId: level.hcpartyId,
-              extractedKeys: level.extractedKeys.filter((key) => !acc.some((previousLevel) => previousLevel.extractedKeys.includes(key))),
-            },
-          ])
-        }, [] as Array<{ hcpartyId: string; extractedKeys: Array<string> }>)
-        .filter((l) => l.extractedKeys.length > 0)
-        .forEach(({ hcpartyId, extractedKeys }) => {
-          ;(perHcpId[hcpartyId] || (perHcpId[hcpartyId] = [])).push(...extractedKeys)
-        })
-    }
-
-    return _.uniqBy(
-      _.flatMap(
-        await Promise.all(
-          Object.keys(perHcpId).map((hcpId) =>
-            this.findContactsByHCPartyPatientForeignKeys(
-              hcpartyId,
-              new models.ListOfIds({
-                ids: perHcpId[hcpId],
-              })
-            )
-          )
-        )
-      ),
-      (x) => x.id
-    )
-  }
-
-  filterBy(startKey?: string, startDocumentId?: string, limit?: number, body?: models.FilterChainContact): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  listContactsByOpeningDate(startKey: number, endKey: number, hcpartyid: string, startDocumentId?: string, limit?: number): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  listServices(body?: ListOfIds): Promise<Array<Service>> {
-    throw new Error('Cannot call a method that returns services without providing a user for de/encryption')
-  }
-
-  findByHCPartyFormId(hcPartyId?: string, formId?: string): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  findByHCPartyFormIds(hcPartyId?: string, body?: models.ListOfIds): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  getContact(contactId: string): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  getContacts(body?: models.ListOfIds): never {
-    throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption')
-  }
-
-  modifyContact(body?: Contact): never {
-    throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption')
-  }
-
-  modifyContacts(body?: Array<Contact>): never {
-    throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption')
-  }
-
-  createContact(body?: Contact): never {
-    throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption')
-  }
-
-  findByHCPartyPatientSecretFKeys(
-    hcPartyId: string,
-    secretFKeys: string,
-    planOfActionIds?: string,
-    skipClosedContacts?: boolean
-  ): Promise<Array<models.Contact> | any> {
-    return super
-      .findByHCPartyPatientSecretFKeys(hcPartyId, secretFKeys, planOfActionIds, skipClosedContacts)
-      .then((contacts) => this.decrypt(hcPartyId, contacts))
-  }
-
-  findByHCPartyPatientSecretFKeysArray(
-    hcPartyId: string,
-    secretFKeys: string[],
-    planOfActionIds?: string,
-    skipClosedContacts?: boolean
-  ): Promise<Array<models.Contact> | any> {
-    return super
-      .findByHCPartyPatientSecretFKeysUsingPost(hcPartyId, planOfActionIds, skipClosedContacts, secretFKeys)
-      .then((contacts) => this.decrypt(hcPartyId, contacts))
-  }
-
-  filterByWithUser(
-    user: models.User,
-    startDocumentId?: string,
-    limit?: number,
-    body?: models.FilterChainContact
-  ): Promise<PaginatedListContact | any> {
-    return super
-      .filterContactsBy(startDocumentId, limit, body)
-      .then((ctcs) =>
-        this.decrypt(user.healthcarePartyId! || user.patientId!, ctcs.rows!).then((decryptedRows) => Object.assign(ctcs, { rows: decryptedRows }))
-      )
-  }
-
-  listContactsByOpeningDateWithUser(
-    user: models.User,
-    startKey: number,
-    endKey: number,
-    hcpartyid: string,
-    startDocumentId?: string,
-    limit?: number
-  ): Promise<PaginatedListContact | any> {
-    return super
-      .listContactsByOpeningDate(startKey, endKey, hcpartyid, startDocumentId, limit)
-      .then((ctcs) =>
-        this.decrypt(user.healthcarePartyId! || user.patientId!, ctcs.rows!).then((decryptedRows) => Object.assign(ctcs, { rows: decryptedRows }))
-      )
-  }
-
-  listServicesWithUser(user: models.User, serviceIds: ListOfIds): Promise<Array<Service> | any> {
-    return super
-      .filterServicesBy(undefined, serviceIds.ids?.length, new FilterChainService({ filter: new ServiceByIdsFilter({ ids: serviceIds.ids }) }))
-      .then((paginatedList) => this.decryptServices(user.healthcarePartyId! || user.patientId!, paginatedList.rows ?? [], undefined, undefined))
-  }
-
-  findByHCPartyFormIdWithUser(user: models.User, hcPartyId: string, formId: string): Promise<Array<models.Contact> | any> {
-    return super.findByHCPartyFormId(hcPartyId, formId).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, ctcs))
-  }
-
-  findByHCPartyFormIdsWithUser(user: models.User, hcPartyId: string, body: models.ListOfIds): Promise<Array<models.Contact> | any> {
-    return super.findByHCPartyFormIds(hcPartyId, body).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, ctcs))
-  }
-
-  getContactWithUser(user: models.User, contactId: string): Promise<models.Contact | any> {
-    return super
-      .getContact(contactId)
-      .then((ctc) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, [ctc]))
-      .then((ctcs) => ctcs[0])
-  }
-
-  getContactsWithUser(user: models.User, body?: models.ListOfIds): Promise<Array<models.Contact> | any> {
-    return super.getContacts(body).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, ctcs))
-  }
-
-  async modifyContactWithUser(user: models.User, body?: models.Contact): Promise<models.Contact | any> {
-    return body
-      ? this.encrypt(user, [_.cloneDeep(body)])
-          .then((ctcs) => super.modifyContact(ctcs[0]))
-          .then((ctc) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, [ctc]))
-          .then((ctcs) => ctcs[0])
-      : null
-  }
-
-  async modifyContactsWithUser(user: models.User, bodies?: Array<models.Contact>): Promise<models.Contact[] | any> {
-    return bodies
-      ? this.encrypt(
-          user,
-          bodies.map((c) => _.cloneDeep(c))
-        )
-          .then((ctcs) => super.modifyContacts(ctcs))
-          .then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, ctcs))
-      : null
-  }
-
-  async createContactWithUser(user: models.User, body?: models.Contact): Promise<models.Contact | any> {
-    return body
-      ? this.encrypt(user, [_.cloneDeep(body)])
-          .then((ctcs) => super.createContact(ctcs[0]))
-          .then((ctc) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, [ctc]))
-          .then((ctcs) => ctcs[0])
-      : null
-  }
-
-  async createContactsWithUser(user: models.User, bodies?: Array<models.Contact>): Promise<models.Contact[] | any> {
-    return bodies
-      ? this.encrypt(
-          user,
-          bodies.map((c) => _.cloneDeep(c))
-        )
-          .then((ctcs) => super.createContacts(ctcs))
-          .then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerOf(user)!, ctcs))
-      : null
-  }
-
-  encryptServices(key: CryptoKey, rawKey: string, services: Service[]): PromiseLike<Service[]> {
-    return Promise.all(
-      services.map(async (svc) => {
-        if (!svc.content) {
-          return svc
-        }
-
-        if (
-          Object.values(svc.content).every(
-            (c) =>
-              c.compoundValue &&
-              !c.stringValue &&
-              !c.documentId &&
-              !c.measureValue &&
-              !c.medicationValue &&
-              (c.booleanValue === null || c.booleanValue === undefined) &&
-              (c.numberValue === null || c.numberValue === undefined) &&
-              !c.instantValue &&
-              !c.fuzzyDateValue &&
-              !c.binaryValue
-          )
-        ) {
-          svc.content = _.fromPairs(
-            await Promise.all(
-              _.toPairs(svc.content).map(async (p) => {
-                if (p[1].compoundValue?.length) {
-                  p[1].compoundValue = await this.encryptServices(key, rawKey, p[1].compoundValue!)
-                }
-                return p
-              })
-            )
-          )
-        } else {
-          svc.encryptedSelf = b2a(ua2string(await this.crypto.AES.encrypt(key, utf8_2ua(JSON.stringify({ content: svc.content })), rawKey)))
-          delete svc.content
-        }
-        return svc
-      })
-    )
-  }
-
-  encrypt(user: models.User, ctcs: Array<models.Contact>) {
-    const hcpartyId = this.dataOwnerApi.getDataOwnerOf(user)!
-    const bypassEncryption = false //Used for debug
-
-    return Promise.all(
-      ctcs.map(async (ctc) => {
-        const initialisedCtc = bypassEncryption //Prevent encryption for test ctc
-          ? ctc
-          : await (ctc.encryptionKeys && Object.keys(ctc.encryptionKeys || {}).length ? Promise.resolve(ctc) : this.initEncryptionKeys(user, ctc))
-
-        const sfks: {
-          extractedKeys: Array<string>
-          hcpartyId: string
-        } = await this.crypto.extractKeysFromDelegationsForHcpHierarchy(hcpartyId, initialisedCtc.id!, initialisedCtc.encryptionKeys!)
-        const rawKey = sfks.extractedKeys[0].replace(/-/g, '')
-        const key = await this.crypto.AES.importKey('raw', hex2ua(rawKey))
-
-        initialisedCtc.services = await this.encryptServices(key, rawKey, ctc.services || [])
-        initialisedCtc.encryptedSelf = b2a(ua2string(await this.crypto.AES.encrypt(key, utf8_2ua(JSON.stringify({ descr: ctc.descr })), rawKey)))
-        delete initialisedCtc.descr
-
-        return initialisedCtc
-      })
-    )
-  }
-
-  decrypt(hcpartyId: string, ctcs: Array<models.Contact>): Promise<Array<models.Contact>> {
-    return Promise.all(
-      ctcs.map(async (ctc) => {
-        const { extractedKeys: sfks } = await this.crypto.extractKeysFromDelegationsForHcpHierarchy(
-          hcpartyId,
-          ctc.id!,
-          _.size(ctc.encryptionKeys) ? ctc.encryptionKeys! : ctc.delegations!
-        )
-        if (!sfks || !sfks.length) {
-          console.log('Cannot decrypt contact', ctc.id)
-          return ctc
-        }
-        const rawKey = sfks[0].replace(/-/g, '')
-        const key = await this.crypto.AES.importKey('raw', hex2ua(rawKey))
-
-        ctc.services = await this.decryptServices(hcpartyId, ctc.services || [], key, rawKey)
-        if (ctc.encryptedSelf) {
-          try {
-            const dec = await this.crypto.AES.decrypt(key, string2ua(a2b(ctc.encryptedSelf!)), rawKey)
-            let jsonContent
-            try {
-              jsonContent = dec && ua2utf8(dec)
-              jsonContent && _.assign(ctc, JSON.parse(jsonContent))
-            } catch (e) {
-              console.log('Cannot parse ctc', ctc.id, jsonContent || '<- Invalid encoding')
-            }
-          } catch {
-            console.log('Cannot decrypt contact', ctc.id)
-          }
-        }
-        return ctc
-      })
-    )
-  }
-
-  decryptServices(hcpartyId: string, svcs: Array<models.Service>, key?: CryptoKey, rawKey?: string): Promise<Array<models.Service>> {
-    return Promise.all(
-      svcs.map(async (svc) => {
-        if (!key) {
-          const { extractedKeys: sfks } = await this.crypto.extractKeysFromDelegationsForHcpHierarchy(
-            hcpartyId,
-            svc.id!,
-            _.size(svc.encryptionKeys) ? svc.encryptionKeys! : svc.delegations!
-          )
-          key = await this.crypto.AES.importKey('raw', hex2ua(sfks[0].replace(/-/g, '')))
-        }
-
-        if (svc.encryptedContent) {
-          try {
-            const dec = await this.crypto.AES.decrypt(key, string2ua(a2b(svc.encryptedContent!)))
-            let jsonContent
-            try {
-              jsonContent = ua2utf8(truncateTrailingNulls(new Uint8Array(dec)))
-              Object.assign(svc, { content: JSON.parse(jsonContent) })
-            } catch (e) {
-              console.log('Cannot parse service', svc.id, jsonContent || '<- Invalid encoding')
-            }
-          } catch {
-            console.log('Cannot decrypt service', svc.id)
-          }
-        } else if (svc.encryptedSelf) {
-          try {
-            const dec = await this.crypto.AES.decrypt(key, string2ua(a2b(svc.encryptedSelf!)))
-            let jsonContent
-            try {
-              jsonContent = ua2utf8(truncateTrailingNulls(new Uint8Array(dec)))
-              Object.assign(svc, JSON.parse(jsonContent))
-            } catch (e) {
-              console.log('Cannot parse service', svc.id, jsonContent || '<- Invalid encoding')
-            }
-          } catch {
-            console.log('Cannot decrypt service', svc.id)
-          }
-        } else {
-          svc.content = _.fromPairs(
-            await Promise.all(
-              _.toPairs(svc.content).map(async (p) => {
-                if (p[1].compoundValue) {
-                  p[1].compoundValue = await this.decryptServices(hcpartyId, p[1].compoundValue, key, rawKey)
-                }
-                return p
-              })
-            )
-          )
-        }
-        return svc
-      })
-    )
-  }
-
-  contactOfService(ctcs: Array<models.Contact>, svcId: string): models.Contact | undefined {
-    let latestContact: models.Contact | undefined = undefined
-    let latestService: models.Service
-    ctcs.forEach((c) => {
-      const s: models.Service | undefined = c.services!.find((it) => svcId === it.id)
-      if (s && (!latestService || moment(s.valueDate).isAfter(moment(latestService.valueDate)))) {
-        latestContact = c
-        latestService = s
-      }
-    })
-    return latestContact
-  }
-
-  filteredServices(ctcs: Array<models.Contact>, filter: any): Array<models.Service> {
-    const byIds: { [key: string]: models.Service } = {}
-    ctcs.forEach((c) =>
-      (c.services || [])
-        .filter((s) => filter(s, c))
-        .forEach((s) => {
-          const ps = byIds[s.id!]
-          if (!ps || !ps.modified || (s.modified && ps.modified < s.modified)) {
-            byIds[s.id!] = s
-            s.contactId = c.id
-          }
-        })
-    )
-    return _.values(byIds).filter((s: any) => !s.deleted && !s.endOfLife)
-  }
-
-  //Return a promise
-  filterServices(ctcs: Array<models.Contact>, filter: any): Promise<Array<models.Service>> {
-    return Promise.resolve(this.filteredServices(ctcs, filter))
-  }
-
-  services(ctc: models.Contact, label: string) {
-    return ctc.services!.filter((s) => s.label === label)
-  }
-
-  preferredContent(svc: models.Service, lng: string) {
-    return (
-      svc && svc.content && (svc.content[lng] || svc.content['fr'] || (Object.keys(svc.content)[0] ? svc.content[Object.keys(svc.content)[0]] : null))
-    )
-  }
-
-  contentValue(c: models.Content) {
-    return (
-      c.stringValue ||
-      ((c.numberValue || c.numberValue === 0) && c.numberValue) ||
-      (c.measureValue && (c.measureValue.value || c.measureValue.value === 0) ? c.measureValue : null) ||
-      c.medicationValue ||
-      c.booleanValue
-    )
-  }
-
-  shortServiceDescription(svc: models.Service, lng: string) {
-    const c = this.preferredContent(svc, lng)
-    return !c ? '' : this.shortContentDescription(c, lng, svc.label)
-  }
-
-  shortContentDescription(c: models.Content, lng: string, label?: string) {
-    return (
-      c.stringValue ||
-      ((c.numberValue || c.numberValue === 0) && c.numberValue) ||
-      (c.measureValue &&
-        '' +
-          (c.measureValue.value || c.measureValue.value === 0 ? c.measureValue.value : '-') +
-          (c.measureValue.unit ? ' ' + c.measureValue.unit : '')) ||
-      (c.medicationValue ? this.medication().medicationToString(c.medicationValue, lng) : null) ||
-      (c.booleanValue && label) ||
-      'OK'
-    )
-  }
-
-  medicationValue(svc: models.Service, lng: string) {
-    const c =
-      svc && svc.content && (svc.content[lng] || svc.content['fr'] || (Object.keys(svc.content)[0] ? svc.content[Object.keys(svc.content)[0]] : null))
-    return c && c.medicationValue
-  }
-
-  contentHasData(c: any): boolean {
-    return c.stringValue || c.numberValue || c.measureValue || c.booleanValue || c.booleanValue === false || c.medicationValue || c.documentId
-  }
-
-  localize(e: any, lng: string) {
-    if (!e) {
-      return null
-    }
-    return e[lng] || e.fr || e.en || e.nl
-  }
-
-  /**
-   * Modifies the subcontacts this svc belongs to while minimizing the number of references to the svcs inside the subcontacts
-   * After the invocation, there is at least one subcontact with provided poaId and heId that contains the svc
-   * The svc is not removed from a previous subcontact it would belong to except if the new conditions are compatible
-   * Note that undefined and null do not have the same meaning for formId
-   * If formId is null: the subcontact which refers svc must have a null formId
-   * If formId is undefined, the subcontact can have any value for formId
-   *
-   * When a svc does not exist yet in the current contact but exists in a previous contact, all the scs it was belonging to are
-   * copied in the current contact
-   *
-   * the svc returned is the one that's inside the ctc
-   *
-   * @param ctc
-   * @param user
-   * @param ctcs
-   * @param svc
-   * @param formId
-   * @param poaId aMap {heId2: [poaId11, poaId12], heId2: [poaId21] }
-   * @param heId an Array of heIds, equivalent to poaIds = {heId: [], ...}
-   * @param init
-   * @returns {*}
-   */
-
-  promoteServiceInContact(
-    ctc: models.Contact,
-    user: models.User,
-    ctcs: Array<models.Contact>,
-    svc: models.Service,
-    formId: string,
-    poaIds?: { [key: string]: string[] },
-    heIds?: Array<string>,
-    init?: any
-  ) {
-    if (!ctc) {
-      return null
-    }
-    const existing = ctc.services!.find((s) => s.id === svc.id)
-    const promoted = _.extend(_.extend(existing || {}, svc), {
-      author: user.id,
-      responsible: this.dataOwnerApi.getDataOwnerOf(user),
-      modified: new Date().getTime(),
-    })
-    if (!existing) {
-      ;(ctc.services || (ctc.services = [])).push(promoted)
-    }
-    const allSubcontactsInCurrentContactContainingService = (ctc.subContacts || []).filter((csc) =>
-      (csc.services || []).some((s) => s.serviceId === svc.id)
-    )
-
-    //Rearrange poaIds and heIds as a hierarchy
-    const hierarchyOfHeAndPoaIds: { [key: string]: Array<any> } = {}
-    ;(heIds || []).forEach((id) => (hierarchyOfHeAndPoaIds[id || '_'] = []))
-    Object.keys(poaIds || {}).forEach((k: string) => {
-      const poas = hierarchyOfHeAndPoaIds[k]
-      if (poas) {
-        hierarchyOfHeAndPoaIds[k] = _.concat(poas, (poaIds || {})[k])
-      } else {
-        hierarchyOfHeAndPoaIds[k] = (poaIds || {})[k]
-      }
-    })
-
-    const pastCtc =
-      (svc.contactId && svc.contactId !== ctc.id && ctcs.find((c) => c.id === svc.contactId)) ||
-      ctcs.reduce(
-        (selected: { s: models.Service | null; c: models.Contact | null }, c: models.Contact) => {
-          const candidate = (c.services || []).find((s) => s.id === svc.id)
-          return ctc.id !== c.id && candidate && (selected.s === null || before(selected.s.modified || 0, candidate.modified || 0))
-            ? { s: candidate, c: c }
-            : selected
-        },
-        { s: null, c: null }
-      ).c
-    //Make sure that all scs the svc was belonging to are copied inside the current contact
-    pastCtc &&
-      pastCtc
-        .subContacts!.filter((psc) => psc.services!.some((s) => s.serviceId === svc.id))
-        .forEach((psc) => {
-          const sameInCurrent = allSubcontactsInCurrentContactContainingService.find(
-            (csc) => csc.formId === psc.formId && csc.planOfActionId === psc.planOfActionId && csc.healthElementId === psc.healthElementId
-          )
-          if (sameInCurrent) {
-            if (!sameInCurrent.services!.some((s) => s.serviceId === svc.id)) {
-              sameInCurrent.services!.push({ serviceId: svc.id })
-            }
-          } else {
-            const newSubContact = _.assign(_.assign({}, psc), {
-              services: [{ serviceId: svc.id }],
-            })
-            ctc.subContacts!.push(newSubContact)
-            allSubcontactsInCurrentContactContainingService.push(newSubContact)
-          }
-        })
-
-    if (!Object.keys(hierarchyOfHeAndPoaIds).length) {
-      hierarchyOfHeAndPoaIds._ = [] //Default is to have at least one option with heId equals to null (represented by _)
-    }
-
-    Object.keys(hierarchyOfHeAndPoaIds).forEach((heId: string | null) => {
-      if (heId === '_') {
-        heId = null
-      }
-      const subPoaIds = heId ? hierarchyOfHeAndPoaIds[heId] : []
-      ;((subPoaIds || []).length ? subPoaIds : [null]).forEach((poaId) => {
-        //Create or assign subcontacts for all pairs he/poa (can be null/null)
-        let destinationSubcontact = ctc.subContacts!.find(
-          (sc) =>
-            (!formId || sc.formId === formId) &&
-            ((!poaId && !sc.planOfActionId) || sc.planOfActionId === poaId) &&
-            ((!heId && !sc.healthElementId) || sc.healthElementId === heId)
-        )
-        if (!destinationSubcontact) {
-          ctc.subContacts!.push(
-            (destinationSubcontact = new models.SubContact({
-              formId: formId || undefined,
-              planOfActionId: poaId,
-              healthElementId: heId,
-              services: [],
-            }))
-          )
-        }
-
-        const redundantSubcontact =
-          allSubcontactsInCurrentContactContainingService.find((aSc) => destinationSubcontact === aSc) ||
-          allSubcontactsInCurrentContactContainingService.find(
-            (aSc) =>
-              (!aSc.planOfActionId || aSc.planOfActionId === destinationSubcontact!.planOfActionId) &&
-              (!aSc.healthElementId || aSc.healthElementId === destinationSubcontact!.healthElementId) &&
-              (!aSc.formId || aSc.formId === destinationSubcontact!.formId)
-          ) // Find a compatible sc: one that does not contain extra and ≠ information than the destination
-
-        if (redundantSubcontact && redundantSubcontact !== destinationSubcontact) {
-          redundantSubcontact.services!.splice(
-            redundantSubcontact.services!.findIndex((link) => link.serviceId === svc.id),
-            1
-          )
-        }
-        if (!destinationSubcontact.services!.some((s) => s.serviceId === svc.id)) {
-          destinationSubcontact.services!.push({ serviceId: svc.id! })
-        }
-      })
-    })
-
-    return (init && init(promoted)) || promoted
-  }
-
-  isNumeric(svc: models.Service, lng: string) {
-    const c = this.preferredContent(svc, lng)
-    return c && (c.measureValue || c.numberValue || c.numberValue == 0)
-  }
-
-  service() {
-    return {
-      newInstance: (user: models.User, s: any) =>
-        _.extend(
-          {
-            id: this.crypto.randomUuid(),
-            _type: 'org.taktik.icure.entities.embed.Service',
-            created: new Date().getTime(),
-            modified: new Date().getTime(),
-            responsible: this.dataOwnerApi.getDataOwnerOf(user),
-            author: user.id,
-            codes: [],
-            tags: [],
-            content: {},
-            valueDate: parseInt(moment().format('YYYYMMDDHHmmss')),
-          },
-          s
-        ),
-    }
-  }
-
-  medication() {
-    const regimenScores: any = {
-      afterwakingup: 63000,
-      beforebreakfast: 70000,
-      duringbreakfast: 80000,
-      afterbreakfast: 90000,
-      morning: 100000,
-      betweenbreakfastandlunch: 103000,
-      beforelunch: 113000,
-      midday: 120000,
-      duringlunch: 123000,
-      afterlunch: 130000,
-      afternoon: 140000,
-      betweenlunchanddinner: 160000,
-      beforedinner: 180000,
-      duringdinner: 190000,
-      afterdinner: 200000,
-      evening: 210000,
-      betweendinnerandsleep: 213000,
-      thehourofsleep: 220000,
-      night: 230000,
-      beforemeals: -30000,
-      betweenmeals: -20000,
-      aftermeals: -10000,
-    }
-
-    const myself = {
-      regimenScores: function () {
-        return regimenScores
-      },
-      medicationNameToString: function (m: any): string {
-        return m && m.compoundPrescription
-          ? m.compoundPrescription
-          : m && m.substanceProduct
-          ? myself.productToString(m && m.substanceProduct)
-          : myself.productToString(m && m.medicinalProduct)
-      },
-      reimbursementReasonToString: (m: any, lang: string) => {
-        return m && m.reimbursementReason && m.reimbursementReason.label && m.reimbursementReason.label.hasOwnProperty(lang)
-          ? m.reimbursementReason.label[lang]
-          : ''
-      },
-      medicationToString: (m: any, lang: string) => {
-        let res = `${myself.medicationNameToString(m)}, ${myself.posologyToString(m, lang)}`
-        const reason = myself.reimbursementReasonToString(m, lang)
-        res = m.numberOfPackages
-          ? `${m.numberOfPackages} ${m.numberOfPackages > 1 ? this.i18n[lang].packagesOf : this.i18n[lang].packageOf} ${res}`
-          : res
-        res = m.duration ? `${res} ${this.i18n[lang].during} ${myself.durationToString(m.duration, lang)}` : res
-        res = reason ? `${res} (${reason})` : res
-        return res
-      },
-      productToString: (m: any): string => {
-        if (!m) {
-          return ''
-        }
-        return m.intendedname
-      },
-      posologyToString: (m: any, lang: string) => {
-        if (m) {
-          if (m.instructionForPatient && m.instructionForPatient.length) {
-            return m.instructionForPatient
-          }
-          if (!m.regimen || !m.regimen.length) {
-            return ''
-          }
-
-          const unit =
-            m.regimen[0].administratedQuantity && m.regimen[0].administratedQuantity.administrationUnit
-              ? m.regimen[0].administratedQuantity.administrationUnit.code
-              : m.regimen[0].administratedQuantity && m.regimen[0].administratedQuantity.unit
-          let quantity = m.regimen[0].administratedQuantity && m.regimen[0].administratedQuantity.quantity
-
-          m.regimen.slice(1).find((ri: any) => {
-            const oUnit =
-              ri.administratedQuantity && ri.administratedQuantity.administrationUnit
-                ? ri.administratedQuantity.administrationUnit.code
-                : ri.administratedQuantity && ri.administratedQuantity.unit
-            const oQuantity = ri.administratedQuantity && ri.administratedQuantity.quantity
-
-            if (oQuantity !== quantity) {
-              quantity = -1
-            }
-            return oUnit !== unit && oQuantity !== quantity
-          })
-
-          const cplxRegimen = !unit || quantity < 0
-          const quantityUnit = cplxRegimen ? `1 ${this.i18n[lang].take_s_}` : `${quantity} ${unit || this.i18n[lang].take_s_}`
-
-          const dayPeriod = m.regimen.find((r: any) => r.weekday !== null && r.weekday !== undefined)
-            ? this.i18n[lang].weekly
-            : m.regimen.find((r: any) => r.date)
-            ? this.i18n[lang].monthly
-            : this.i18n[lang].daily
-
-          return `${quantityUnit}, ${m.regimen.length} x ${dayPeriod}, ${_.sortBy(
-            m.regimen,
-            (r) =>
-              (r.date ? r.date * 1000000 : 29990000000000) +
-              (r.dayNumber || 0) * 1000000 +
-              ((r.weekday && r.weekday.weekNumber) || 0) * 7 * 1000000 +
-              (r.timeOfDay ? r.timeOfDay : r.dayPeriod && r.dayPeriod.code ? (regimenScores[r.dayPeriod.code] as number) : 0)
-          )
-            .map((r) => (cplxRegimen ? myself.regimenToExtString(r, lang) : myself.regimenToString(r, lang)))
-            .join(', ')}`
-        }
-      },
-      frequencyToString: (m: any, lang: string) => {
-        if (m.instructionForPatient && m.instructionForPatient.length) {
-          return m.instructionForPatient
-        }
-        if (!m.regimen || !m.regimen.length) {
-          return ''
-        }
-
-        const dayPeriod = m.regimen.find((r: any) => r.weekday !== null && r.weekday !== undefined)
-          ? this.i18n[lang].weekly
-          : m.regimen.find((r: any) => r.date)
-          ? this.i18n[lang].monthly
-          : this.i18n[lang].daily
-
-        return `${m.regimen.length} x ${dayPeriod}`
-      },
-      durationToString: (d: models.Duration, lang: string) => {
-        return d.value ? `${d.value} ${this.localize(d.unit!.label, lang)}` : ''
-      },
-      regimenToExtString: (r: models.RegimenItem, lang: string) => {
-        const desc = myself.regimenToString(r, lang)
-        return (
-          (r.administratedQuantity && r.administratedQuantity.quantity && desc
-            ? `${desc} (${r.administratedQuantity.quantity} ${
-                (r.administratedQuantity.administrationUnit ? r.administratedQuantity.administrationUnit.code : r.administratedQuantity.unit) ||
-                this.i18n[lang].take_s_
-              })`
-            : desc) || ''
-        )
-      },
-      regimenToString: (r: models.RegimenItem, lang: string) => {
-        let res = r.date
-          ? `${this.i18n[lang].the} ${moment(r.date).format('DD/MM/YYYY')}`
-          : r.dayNumber
-          ? `${this.i18n[lang].onDay} ${r.dayNumber}`
-          : r.weekday && r.weekday.weekday
-          ? `${this.i18n[lang].on} ${r.weekday.weekday}`
-          : null
-        if (r.dayPeriod && r.dayPeriod.code && r.dayPeriod.code.length) {
-          res = res
-            ? `${res} ${this.i18n[lang][r.dayPeriod.code] || this.localize(r.dayPeriod.label, lang) || r.dayPeriod.code}`
-            : this.i18n[lang][r.dayPeriod.code] || this.localize(r.dayPeriod.label, lang) || r.dayPeriod.code
-        }
-        if (r.timeOfDay) {
-          const timeOfDay =
-            r.timeOfDay === 120000
-              ? this.i18n[lang].noon
-              : `${Math.floor(r.timeOfDay / 10000)}:${('' + (Math.floor(r.timeOfDay / 100) % 100)).replace(/^(.)$/, '0$1')}`
-          res = res ? res + ' ' + this.i18n[lang].at + ' ' + timeOfDay : timeOfDay
-        }
-        return res
-      },
-      localize: (s: any, lang: string) => {
-        if (!s) {
-          return s
-        }
-        return (
-          this.i18n[lang][s] ||
-          (this.i18n[lang][s.toLowerCase()] &&
-            this.i18n[lang][s.toLowerCase()]
-              .split('')
-              .map((c: string, idx: number) => (idx >= s.length || s[idx].toLocaleLowerCase() === s[idx] ? c : c.toLocaleUpperCase()))
-              .join('')) ||
-          s
-        ) //Applies the (lower/upper)case to the translated lowercase version of the input string (s)
-      },
-    }
-    return myself
-  }
-}