@icure/api 6.3.1 → 7.0.0-beta.0

package/dist/icc-x-api/icc-contact-x-api.js

@@ -0,0 +1,764 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IccContactXApi = void 0;
+const icc_api_1 = require("../icc-api");
+const contact_i18n_1 = require("./rsrc/contact.i18n");
+const moment = require("moment");
+const _ = require("lodash");
+const models = require("../icc-api/model/models");
+const models_1 = require("../icc-api/model/models");
+const binary_utils_1 = require("./utils/binary-utils");
+const ServiceByIdsFilter_1 = require("./filters/ServiceByIdsFilter");
+const utils_1 = require("./utils");
+const AuthenticationProvider_1 = require("./auth/AuthenticationProvider");
+class IccContactXApi extends icc_api_1.IccContactApi {
+    constructor(host, headers, crypto, dataOwnerApi, authenticationProvider = new AuthenticationProvider_1.NoAuthenticationProvider(), fetchImpl = typeof window !== 'undefined'
+        ? window.fetch
+        : typeof self !== 'undefined'
+            ? self.fetch
+            : fetch) {
+        super(host, headers, authenticationProvider, fetchImpl);
+        this.i18n = contact_i18n_1.default;
+        this.crypto = crypto;
+        this.dataOwnerApi = dataOwnerApi;
+    }
+    /**
+     * Creates a new instance of contact with initialised encryption metadata (not in the database).
+     * @param user the current user.
+     * @param patient the patient this contact refers to.
+     * @param c initialised data for the contact. Metadata such as id, creation data, etc. will be automatically initialised, but you can specify other
+     * kinds of data or overwrite generated metadata with this. You can't specify encryption metadata.
+     * @param options optional parameters:
+     * - additionalDelegates: delegates which will have access to the entity in addition to the current data owner and delegates from the
+     * auto-delegations. Must be an object which associates each data owner id with the access level to give to that data owner. May overlap with
+     * auto-delegations, in such case the access level specified here will be used. Currently only WRITE access is supported, but in future also read
+     * access will be possible.
+     * - preferredSfk: secret id of the patient to use as the secret foreign key to use for the classification. The default value will be a
+     * secret id of patient known by the topmost parent in the current data owner hierarchy.
+     * - confidential: if true, the entity will be created as confidential. Confidential entities are not shared with auto-delegations, and the default
+     * foreign key used is any key that is not shared with any of the data owner parents. By default entities are created as non-confidential.
+     * @return a new instance of contact.
+     */
+    newInstance(user, patient, c, options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            const contact = new models.Contact(_.extend({
+                id: this.crypto.primitives.randomUuid(),
+                _type: 'org.taktik.icure.entities.Contact',
+                created: new Date().getTime(),
+                modified: new Date().getTime(),
+                responsible: this.dataOwnerApi.getDataOwnerIdOf(user),
+                author: user.id,
+                codes: [],
+                tags: [],
+                groupId: this.crypto.primitives.randomUuid(),
+                subContacts: [],
+                services: [],
+                openingDate: parseInt(moment().format('YYYYMMDDHHmmss')),
+            }, c || {}));
+            const ownerId = this.dataOwnerApi.getDataOwnerIdOf(user);
+            if (ownerId !== (yield this.dataOwnerApi.getCurrentDataOwnerId()))
+                throw new Error('Can only initialise entities as current data owner.');
+            const sfk = (_a = options.preferredSfk) !== null && _a !== void 0 ? _a : (!!options.confidential
+                ? yield this.crypto.confidential.getConfidentialSecretId(patient)
+                : yield this.crypto.confidential.getAnySecretIdSharedWithParents(patient));
+            if (!sfk)
+                throw new Error(`Couldn't find any sfk of parent patient ${patient.id} for confidential=${!!options.confidential}`);
+            const extraDelegations = [
+                ...Object.keys((_b = options.additionalDelegates) !== null && _b !== void 0 ? _b : {}),
+                ...(options.confidential ? [] : [...((_d = (_c = user.autoDelegations) === null || _c === void 0 ? void 0 : _c.all) !== null && _d !== void 0 ? _d : []), ...((_f = (_e = user.autoDelegations) === null || _e === void 0 ? void 0 : _e.medicalInformation) !== null && _f !== void 0 ? _f : [])]),
+            ];
+            const initialisationInfo = yield this.crypto.entities.entityWithInitialisedEncryptedMetadata(contact, patient.id, sfk, true, extraDelegations);
+            return new models.Contact(initialisationInfo.updatedEntity);
+        });
+    }
+    /**
+     * 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, patient, usingPost = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.crypto.entities.secretIdsForHcpHierarchyOf(patient).then((keysHierarchy) => keysHierarchy && keysHierarchy.length > 0
+                ? Promise.all(keysHierarchy
+                    .reduce((acc, level) => {
+                    return acc.concat([
+                        {
+                            hcpartyId: level.ownerId,
+                            extractedKeys: level.extracted.filter((key) => !acc.some((previousLevel) => previousLevel.extractedKeys.includes(key))),
+                        },
+                    ]);
+                }, [])
+                    .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([]));
+        });
+    }
+    findByPatientSFKs(hcpartyId, patients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const perHcpId = {};
+            for (const patient of patients) {
+                ;
+                (yield this.crypto.entities.secretIdsForHcpHierarchyOf(patient))
+                    .reduce((acc, level) => {
+                    return acc.concat([
+                        {
+                            hcpartyId: level.ownerId,
+                            extractedKeys: level.extracted.filter((key) => !acc.some((previousLevel) => previousLevel.extractedKeys.includes(key))),
+                        },
+                    ]);
+                }, [])
+                    .filter((l) => l.extractedKeys.length > 0)
+                    .forEach(({ hcpartyId, extractedKeys }) => {
+                    ;
+                    (perHcpId[hcpartyId] || (perHcpId[hcpartyId] = [])).push(...extractedKeys);
+                });
+            }
+            return _.uniqBy(_.flatMap(yield Promise.all(Object.keys(perHcpId).map((hcpId) => this.findContactsByHCPartyPatientForeignKeys(hcpartyId, new models.ListOfIds({
+                ids: perHcpId[hcpId],
+            }))))), (x) => x.id);
+        });
+    }
+    filterBy(startKey, startDocumentId, limit, body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listContactsByOpeningDate(startKey, endKey, hcpartyid, startDocumentId, limit) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listServices(body) {
+        throw new Error('Cannot call a method that returns services without providing a user for de/encryption');
+    }
+    findByHCPartyFormId(hcPartyId, formId) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    findByHCPartyFormIds(hcPartyId, body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    getContact(contactId) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    getContacts(body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    modifyContact(body) {
+        throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption');
+    }
+    modifyContacts(body) {
+        throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption');
+    }
+    createContact(body) {
+        throw new Error('Cannot call a method that modify contacts without providing a user for de/encryption');
+    }
+    findByHCPartyPatientSecretFKeys(hcPartyId, secretFKeys, planOfActionIds, skipClosedContacts) {
+        return super
+            .findByHCPartyPatientSecretFKeys(hcPartyId, secretFKeys, planOfActionIds, skipClosedContacts)
+            .then((contacts) => this.decrypt(hcPartyId, contacts));
+    }
+    findByHCPartyPatientSecretFKeysArray(hcPartyId, secretFKeys, planOfActionIds, skipClosedContacts) {
+        return super
+            .findByHCPartyPatientSecretFKeysUsingPost(hcPartyId, planOfActionIds, skipClosedContacts, secretFKeys)
+            .then((contacts) => this.decrypt(hcPartyId, contacts));
+    }
+    filterByWithUser(user, startDocumentId, limit, body) {
+        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, startKey, endKey, hcpartyid, startDocumentId, limit) {
+        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, serviceIds) {
+        var _a;
+        return super
+            .filterServicesBy(undefined, (_a = serviceIds.ids) === null || _a === void 0 ? void 0 : _a.length, new models_1.FilterChainService({ filter: new ServiceByIdsFilter_1.ServiceByIdsFilter({ ids: serviceIds.ids }) }))
+            .then((paginatedList) => { var _a; return this.decryptServices(user.healthcarePartyId || user.patientId, (_a = paginatedList.rows) !== null && _a !== void 0 ? _a : []); });
+    }
+    findByHCPartyFormIdWithUser(user, hcPartyId, formId) {
+        return super.findByHCPartyFormId(hcPartyId, formId).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs));
+    }
+    findByHCPartyFormIdsWithUser(user, hcPartyId, body) {
+        return super.findByHCPartyFormIds(hcPartyId, body).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs));
+    }
+    getContactWithUser(user, contactId) {
+        return super
+            .getContact(contactId)
+            .then((ctc) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), [ctc]))
+            .then((ctcs) => ctcs[0]);
+    }
+    getContactsWithUser(user, body) {
+        return super.getContacts(body).then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs));
+    }
+    modifyContactWithUser(user, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return body ? this.modifyAs(this.dataOwnerApi.getDataOwnerIdOf(user), body) : null;
+        });
+    }
+    modifyAs(dataOwner, contact) {
+        return this.encryptAs(dataOwner, [_.cloneDeep(contact)])
+            .then((ctcs) => super.modifyContact(ctcs[0]))
+            .then((ctc) => this.decrypt(dataOwner, [ctc]))
+            .then((ctcs) => ctcs[0]);
+    }
+    modifyContactsWithUser(user, bodies) {
+        const _super = Object.create(null, {
+            modifyContacts: { get: () => super.modifyContacts }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return bodies
+                ? this.encrypt(user, bodies.map((c) => _.cloneDeep(c)))
+                    .then((ctcs) => _super.modifyContacts.call(this, ctcs))
+                    .then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs))
+                : null;
+        });
+    }
+    createContactWithUser(user, body) {
+        const _super = Object.create(null, {
+            createContact: { get: () => super.createContact }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return body
+                ? this.encrypt(user, [_.cloneDeep(body)])
+                    .then((ctcs) => _super.createContact.call(this, ctcs[0]))
+                    .then((ctc) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), [ctc]))
+                    .then((ctcs) => ctcs[0])
+                : null;
+        });
+    }
+    createContactsWithUser(user, bodies) {
+        const _super = Object.create(null, {
+            createContacts: { get: () => super.createContacts }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return bodies
+                ? this.encrypt(user, bodies.map((c) => _.cloneDeep(c)))
+                    .then((ctcs) => _super.createContacts.call(this, ctcs))
+                    .then((ctcs) => this.decrypt(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs))
+                : null;
+        });
+    }
+    encryptServices(key, rawKey, services) {
+        return Promise.all(services.map((svc) => __awaiter(this, void 0, void 0, function* () {
+            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(yield Promise.all(_.toPairs(svc.content).map((p) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if ((_a = p[1].compoundValue) === null || _a === void 0 ? void 0 : _a.length) {
+                        p[1].compoundValue = yield this.encryptServices(key, rawKey, p[1].compoundValue);
+                    }
+                    return p;
+                }))));
+            }
+            else {
+                svc.encryptedSelf = (0, binary_utils_1.b2a)((0, binary_utils_1.ua2string)(yield this.crypto.primitives.AES.encrypt(key, (0, binary_utils_1.utf8_2ua)(JSON.stringify({ content: svc.content })), rawKey)));
+                delete svc.content;
+            }
+            return svc;
+        })));
+    }
+    encrypt(user, ctcs) {
+        return this.encryptAs(this.dataOwnerApi.getDataOwnerIdOf(user), ctcs);
+    }
+    encryptAs(hcpartyId, ctcs) {
+        const bypassEncryption = false; //Used for debug
+        return Promise.all(ctcs.map((ctc) => __awaiter(this, void 0, void 0, function* () {
+            const initialisedCtc = bypassEncryption //Prevent encryption for test ctc
+                ? ctc
+                : yield this.crypto.entities.ensureEncryptionKeysInitialised(ctc);
+            const encryptionKey = yield this.crypto.entities.importFirstValidKey(yield this.crypto.entities.encryptionKeysOf(ctc, hcpartyId), ctc.id);
+            initialisedCtc.services = yield this.encryptServices(encryptionKey.key, encryptionKey.raw, ctc.services || []);
+            initialisedCtc.encryptedSelf = (0, binary_utils_1.b2a)((0, binary_utils_1.ua2string)(yield this.crypto.primitives.AES.encrypt(encryptionKey.key, (0, binary_utils_1.utf8_2ua)(JSON.stringify({ descr: ctc.descr })), encryptionKey.raw)));
+            delete initialisedCtc.descr;
+            return initialisedCtc;
+        })));
+    }
+    decrypt(hcpartyId, ctcs) {
+        return Promise.all(ctcs.map((ctc) => __awaiter(this, void 0, void 0, function* () {
+            const keys = yield this.crypto.entities.importAllValidKeys(yield this.crypto.entities.encryptionKeysOf(ctc, hcpartyId));
+            if (!keys || !keys.length) {
+                console.log('Cannot decrypt contact', ctc.id);
+                return ctc;
+            }
+            ctc.services = yield this.decryptServices(hcpartyId, ctc.services || [], keys);
+            if (ctc.encryptedSelf) {
+                try {
+                    const json = yield this.crypto.entities.tryDecryptJson(keys, (0, binary_utils_1.string2ua)((0, binary_utils_1.a2b)(ctc.encryptedSelf)), false);
+                    if (json) {
+                        _.assign(ctc, json);
+                    }
+                    else {
+                        console.log('Cannot decrypt ctc: no valid key could produce valid json', ctc.id);
+                    }
+                }
+                catch (e) {
+                    console.log('Failed to decrypt ctc', ctc.id, e);
+                }
+            }
+            return ctc;
+        })));
+    }
+    decryptServices(hcpartyId, svcs, keys) {
+        return Promise.all(svcs.map((svc) => __awaiter(this, void 0, void 0, function* () {
+            if (!keys) {
+                keys = yield this.crypto.entities.importAllValidKeys(yield this.crypto.entities.encryptionKeysOf(svc, hcpartyId));
+            }
+            if (svc.encryptedContent) {
+                try {
+                    const json = yield this.crypto.entities.tryDecryptJson(keys, (0, binary_utils_1.string2ua)((0, binary_utils_1.a2b)(svc.encryptedContent)), true);
+                    if (json) {
+                        Object.assign(svc, { content: json });
+                    }
+                    else {
+                        console.log('Cannot decrypt service: no valid key could produce valid json', svc.id);
+                    }
+                }
+                catch (e) {
+                    console.log('Cannot decrypt service', svc.id, e);
+                }
+            }
+            else if (svc.encryptedSelf) {
+                try {
+                    const json = yield this.crypto.entities.tryDecryptJson(keys, (0, binary_utils_1.string2ua)((0, binary_utils_1.a2b)(svc.encryptedSelf)), true);
+                    if (json) {
+                        Object.assign(svc, json);
+                    }
+                    else {
+                        console.log('Cannot decrypt service: no valid key could produce valid json', svc.id);
+                    }
+                }
+                catch (e) {
+                    console.log('Cannot decrypt service', svc.id, e);
+                }
+            }
+            else {
+                svc.content = _.fromPairs(yield Promise.all(_.toPairs(svc.content).map((p) => __awaiter(this, void 0, void 0, function* () {
+                    if (p[1].compoundValue) {
+                        p[1].compoundValue = yield this.decryptServices(hcpartyId, p[1].compoundValue, keys);
+                    }
+                    return p;
+                }))));
+            }
+            return svc;
+        })));
+    }
+    contactOfService(ctcs, svcId) {
+        let latestContact = undefined;
+        let latestService;
+        ctcs.forEach((c) => {
+            const s = 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, filter) {
+        const byIds = {};
+        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) => !s.deleted && !s.endOfLife);
+    }
+    //Return a promise
+    filterServices(ctcs, filter) {
+        return Promise.resolve(this.filteredServices(ctcs, filter));
+    }
+    services(ctc, label) {
+        return ctc.services.filter((s) => s.label === label);
+    }
+    preferredContent(svc, lng) {
+        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) {
+        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, lng) {
+        const c = this.preferredContent(svc, lng);
+        return !c ? '' : this.shortContentDescription(c, lng, svc.label);
+    }
+    shortContentDescription(c, lng, label) {
+        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, lng) {
+        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) {
+        return c.stringValue || c.numberValue || c.measureValue || c.booleanValue || c.booleanValue === false || c.medicationValue || c.documentId;
+    }
+    localize(e, lng) {
+        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, user, ctcs, svc, formId, poaIds, heIds, init) {
+        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.getDataOwnerIdOf(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 = {};
+        (heIds || []).forEach((id) => (hierarchyOfHeAndPoaIds[id || '_'] = []));
+        Object.keys(poaIds || {}).forEach((k) => {
+            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, c) => {
+                const candidate = (c.services || []).find((s) => s.id === svc.id);
+                return ctc.id !== c.id && candidate && (selected.s === null || (0, utils_1.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) => {
+            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, lng) {
+        const c = this.preferredContent(svc, lng);
+        return c && (c.measureValue || c.numberValue || c.numberValue == 0);
+    }
+    service() {
+        return {
+            newInstance: (user, s) => _.extend({
+                id: this.crypto.primitives.randomUuid(),
+                _type: 'org.taktik.icure.entities.embed.Service',
+                created: new Date().getTime(),
+                modified: new Date().getTime(),
+                responsible: this.dataOwnerApi.getDataOwnerIdOf(user),
+                author: user.id,
+                codes: [],
+                tags: [],
+                content: {},
+                valueDate: parseInt(moment().format('YYYYMMDDHHmmss')),
+            }, s),
+        };
+    }
+    medication() {
+        const regimenScores = {
+            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) {
+                return m && m.compoundPrescription
+                    ? m.compoundPrescription
+                    : m && m.substanceProduct
+                        ? myself.productToString(m && m.substanceProduct)
+                        : myself.productToString(m && m.medicinalProduct);
+            },
+            reimbursementReasonToString: (m, lang) => {
+                return m && m.reimbursementReason && m.reimbursementReason.label && m.reimbursementReason.label.hasOwnProperty(lang)
+                    ? m.reimbursementReason.label[lang]
+                    : '';
+            },
+            medicationToString: (m, lang) => {
+                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) => {
+                if (!m) {
+                    return '';
+                }
+                return m.intendedname;
+            },
+            posologyToString: (m, lang) => {
+                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) => {
+                        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) => r.weekday !== null && r.weekday !== undefined)
+                        ? this.i18n[lang].weekly
+                        : m.regimen.find((r) => 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] : 0))
+                        .map((r) => (cplxRegimen ? myself.regimenToExtString(r, lang) : myself.regimenToString(r, lang)))
+                        .join(', ')}`;
+                }
+            },
+            frequencyToString: (m, lang) => {
+                if (m.instructionForPatient && m.instructionForPatient.length) {
+                    return m.instructionForPatient;
+                }
+                if (!m.regimen || !m.regimen.length) {
+                    return '';
+                }
+                const dayPeriod = m.regimen.find((r) => r.weekday !== null && r.weekday !== undefined)
+                    ? this.i18n[lang].weekly
+                    : m.regimen.find((r) => r.date)
+                        ? this.i18n[lang].monthly
+                        : this.i18n[lang].daily;
+                return `${m.regimen.length} x ${dayPeriod}`;
+            },
+            durationToString: (d, lang) => {
+                return d.value ? `${d.value} ${this.localize(d.unit.label, lang)}` : '';
+            },
+            regimenToExtString: (r, lang) => {
+                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, lang) => {
+                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, lang) => {
+                if (!s) {
+                    return s;
+                }
+                return (this.i18n[lang][s] ||
+                    (this.i18n[lang][s.toLowerCase()] &&
+                        this.i18n[lang][s.toLowerCase()]
+                            .split('')
+                            .map((c, idx) => (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;
+    }
+    /**
+     * @param contact a contact
+     * @return the id of the patient that the contact refers to, retrieved from the encrypted metadata. Normally there should only be one element
+     * in the returned array, but in case of entity merges there could be multiple values.
+     */
+    decryptPatientIdOf(contact) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.crypto.entities.owningEntityIdsOf(contact, undefined);
+        });
+    }
+    /**
+     * Share an existing contact with other data owners, allowing them to access the non-encrypted data of the contact and optionally also
+     * the encrypted content.
+     * @param delegateId the id of the data owner which will be granted access to the contact.
+     * @param contact the contact to share.
+     * @param options optional parameters to customize the sharing behaviour:
+     * - shareEncryptionKey: specifies if the encryption key of the access log should be shared with the delegate, giving access to all encrypted
+     * content of the entity, excluding other encrypted metadata (defaults to {@link ShareMetadataBehaviour.IF_AVAILABLE}). Note that by default a
+     * contact does not have encrypted content.
+     * - sharePatientId: specifies if the id of the patient that this contact refers to should be shared with the delegate (defaults to
+     * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
+     * @return a promise which will contain the updated contact.
+     */
+    shareWith(delegateId, contact, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const self = yield this.dataOwnerApi.getCurrentDataOwnerId();
+            return yield this.modifyAs(self, yield this.crypto.entities.entityWithAutoExtendedEncryptedMetadata(contact, delegateId, undefined, options.shareEncryptionKey, options.sharePatientId));
+        });
+    }
+}
+exports.IccContactXApi = IccContactXApi;
+//# sourceMappingURL=icc-contact-x-api.js.map