@icure/api 6.3.1 → 7.0.0-beta.0

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

@@ -0,0 +1,829 @@
+"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.IccPatientXApi = void 0;
+const icc_api_1 = require("../icc-api");
+const _ = require("lodash");
+const models = require("../icc-api/model/models");
+const models_1 = require("../icc-api/model/models");
+const ModelHelper_1 = require("../icc-api/model/ModelHelper");
+const person_util_1 = require("./utils/person-util");
+const utils_1 = require("./utils");
+const AuthenticationProvider_1 = require("./auth/AuthenticationProvider");
+const ShareMetadataBehaviour_1 = require("./crypto/ShareMetadataBehaviour");
+// noinspection JSUnusedGlobalSymbols
+class IccPatientXApi extends icc_api_1.IccPatientApi {
+    constructor(host, headers, crypto, contactApi, formApi, helementApi, invoiceApi, documentApi, hcpartyApi, classificationApi, dataOwnerApi, calendarItemaApi, encryptedKeys = ['note'], authenticationProvider = new AuthenticationProvider_1.NoAuthenticationProvider(), fetchImpl = typeof window !== 'undefined'
+        ? window.fetch
+        : typeof self !== 'undefined'
+            ? self.fetch
+            : fetch) {
+        super(host, headers, authenticationProvider, fetchImpl);
+        this.crypto = crypto;
+        this.contactApi = contactApi;
+        this.formApi = formApi;
+        this.helementApi = helementApi;
+        this.invoiceApi = invoiceApi;
+        this.hcpartyApi = hcpartyApi;
+        this.documentApi = documentApi;
+        this.classificationApi = classificationApi;
+        this.calendarItemApi = calendarItemaApi;
+        this.dataOwnerApi = dataOwnerApi;
+        this.encryptedKeys = encryptedKeys;
+    }
+    /**
+     * Creates a new instance of patient with initialised encryption metadata (not in the database).
+     * @param user the current user.
+     * @param p initialised data for the patient. 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.
+     * @return a new instance of patient.
+     */
+    newInstance(user, p = {}, options = {}) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const patient = _.extend({
+                id: this.crypto.primitives.randomUuid(),
+                _type: 'org.taktik.icure.entities.Patient',
+                created: new Date().getTime(),
+                modified: new Date().getTime(),
+                responsible: this.dataOwnerApi.getDataOwnerIdOf(user),
+                author: user.id,
+                codes: [],
+                tags: [],
+            }, p || {});
+            const ownerId = this.dataOwnerApi.getDataOwnerIdOf(user);
+            if (ownerId !== (yield this.dataOwnerApi.getCurrentDataOwnerId()))
+                throw new Error('Can only initialise entities as current data owner.');
+            const extraDelegations = [
+                ...Object.keys((_a = options.additionalDelegates) !== null && _a !== void 0 ? _a : {}),
+                ...((_c = (_b = user.autoDelegations) === null || _b === void 0 ? void 0 : _b.all) !== null && _c !== void 0 ? _c : []),
+                ...((_e = (_d = user.autoDelegations) === null || _d === void 0 ? void 0 : _d.medicalInformation) !== null && _e !== void 0 ? _e : []),
+            ];
+            const initialisationInfo = yield this.crypto.entities.entityWithInitialisedEncryptedMetadata(patient, undefined, undefined, true, extraDelegations);
+            return new models.Patient(initialisationInfo.updatedEntity);
+        });
+    }
+    completeNames(patient) {
+        var _a;
+        let finalPatient = patient;
+        if (!!finalPatient.lastName && !(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Official)) {
+            finalPatient = (0, person_util_1.garnishPersonWithName)(finalPatient, models.PersonName.UseEnum.Official, finalPatient.lastName, finalPatient.firstName);
+        }
+        if (!!finalPatient.maidenName && !(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Maiden)) {
+            finalPatient = (0, person_util_1.garnishPersonWithName)(finalPatient, models.PersonName.UseEnum.Maiden, finalPatient.maidenName, finalPatient.firstName);
+        }
+        if (!!finalPatient.alias && !(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Nickname)) {
+            finalPatient = (0, person_util_1.garnishPersonWithName)(finalPatient, models.PersonName.UseEnum.Nickname, finalPatient.alias, finalPatient.firstName);
+        }
+        if (!finalPatient.lastName && !!(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Official)) {
+            const officialName = (0, person_util_1.findName)(finalPatient, models.PersonName.UseEnum.Official);
+            finalPatient = Object.assign(Object.assign({}, finalPatient), { lastName: officialName.lastName, firstName: (_a = officialName.firstNames) === null || _a === void 0 ? void 0 : _a[0] });
+        }
+        if (!finalPatient.maidenName && !!(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Maiden)) {
+            finalPatient = Object.assign(Object.assign({}, finalPatient), { maidenName: (0, person_util_1.findName)(finalPatient, models.PersonName.UseEnum.Maiden).lastName });
+        }
+        if (!finalPatient.alias && !!(0, person_util_1.hasName)(finalPatient, models.PersonName.UseEnum.Nickname)) {
+            finalPatient = Object.assign(Object.assign({}, finalPatient), { alias: (0, person_util_1.findName)(finalPatient, models.PersonName.UseEnum.Nickname).lastName });
+        }
+        return finalPatient;
+    }
+    /**
+     * @deprecated replace with {@link initConfidentialSecretId}
+     */
+    initConfidentialDelegation(patient, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.initConfidentialSecretId(patient, user);
+        });
+    }
+    /**
+     * Ensures that the current data owner has some confidential secret ids for the provided patient. If not creates them and updates the patient in the
+     * database.
+     * @param patient the patient for which you want to initialise the confidential secret id.
+     * @param user the current user.
+     * @return the updated patient or the original patient if no change was necessary.
+     */
+    initConfidentialSecretId(patient, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataOwnerId = this.dataOwnerApi.getDataOwnerIdOf(user);
+            if (dataOwnerId !== (yield this.dataOwnerApi.getCurrentDataOwnerId()))
+                throw new Error('You can initialise confidential delegations only for the current data owner');
+            const initialised = yield this.crypto.confidential.entityWithInitialisedConfidentialSecretId(patient);
+            if (initialised) {
+                return initialised.rev ? this.modifyPatientWithUser(user, initialised) : this.createPatientWithUser(user, initialised);
+            }
+            else {
+                return patient;
+            }
+        });
+    }
+    createPatient(body) {
+        throw new Error('Cannot call a method that returns patients without providing a user for de/encryption');
+    }
+    createPatientWithUser(user, body) {
+        return body
+            ? this.encrypt(user, [_.cloneDeep(this.completeNames(body))])
+                .then((pats) => super.createPatient(pats[0]))
+                .then((p) => this.decrypt(user, [p]))
+                .then((pats) => pats[0])
+            : Promise.resolve(null);
+    }
+    filterBy(startKey, startDocumentId, limit, skip, sort, desc, body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    filterByWithUser(user, filterChain, startKey, startDocumentId, limit, skip, sort, desc) {
+        return super
+            .filterPatientsBy(startKey, startDocumentId, limit, skip, sort, desc, filterChain)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    findByAccessLogUserAfterDate(userId, accessType, startDate, startKey, startDocumentId, limit) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    findByAccessLogUserAfterDateWithUser(user, userId, accessType, startDate, startKey, startDocumentId, limit) {
+        return super
+            .findByAccessLogUserAfterDate(userId, accessType, startDate, startKey, startDocumentId, limit)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    findByAccessLogUserAfterDate_1(externalId) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    findByExternalIdWithUser(user, externalId) {
+        return super
+            .findByExternalId(externalId)
+            .then((pats) => this.decrypt(user, [pats]))
+            .then((x) => x[0]);
+    }
+    findByNameBirthSsinAuto(healthcarePartyId, filterValue, startKey, startDocumentId, limit, sortDirection) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    findByNameBirthSsinAutoWithUser(user, healthcarePartyId, filterValue, startKey, startDocumentId, limit, sortDirection) {
+        return super
+            .findByNameBirthSsinAuto(healthcarePartyId, filterValue, startKey, startDocumentId, limit, sortDirection)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    fuzzySearch(firstName, lastName, dateOfBirth) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    fuzzySearchWithUser(user, firstName, lastName, dateOfBirth) {
+        return super.fuzzySearch(firstName, lastName, dateOfBirth).then((pats) => this.decrypt(user, pats));
+    }
+    getPatient(patientId) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    getPatientRaw(patientId) {
+        return super.getPatient(patientId);
+    }
+    getPatientWithUser(user, patientId) {
+        return super
+            .getPatient(patientId)
+            .then((p) => this.tryDecryptOrReturnOriginal(this.dataOwnerApi.getDataOwnerIdOf(user), [p], false))
+            .then((pats) => pats[0].entity);
+    }
+    getPotentiallyEncryptedPatientWithUser(user, patientId) {
+        return super
+            .getPatient(patientId)
+            .then((p) => this.tryDecryptOrReturnOriginal(this.dataOwnerApi.getDataOwnerIdOf(user), [p], false))
+            .then((pats) => ({ patient: pats[0].entity, decrypted: pats[0].decrypted }));
+    }
+    getPatients(body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    getPatientsWithUser(user, body) {
+        return super.getPatients(body).then((pats) => this.decrypt(user, pats));
+    }
+    listDeletedPatients(startDate, endDate, desc, startDocumentId, limit) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listDeletedPatientsWithUser(user, startDate, endDate, desc, startDocumentId, limit) {
+        return super
+            .listDeletedPatients(startDate, endDate, desc, startDocumentId, limit)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    listDeletedPatients_2(firstName, lastName) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listDeletedPatientsByNameWithUser(user, firstName, lastName) {
+        return super.listDeletedPatientsByName(firstName, lastName).then((rows) => this.decrypt(user, rows, false));
+    }
+    listOfMergesAfter(date) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listOfMergesAfterWithUser(user, date) {
+        return super.listOfMergesAfter(date).then((pats) => this.decrypt(user, pats, false));
+    }
+    listOfPatientsModifiedAfter(date, startKey, startDocumentId, limit) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listOfPatientsModifiedAfterWithUser(user, date, startKey, startDocumentId, limit) {
+        return super
+            .listOfPatientsModifiedAfter(date, startKey, startDocumentId, limit)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    listPatients(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listPatientsWithUser(user, hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        return super
+            .listPatients(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    listPatientsByHcParty(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listPatientsByHcPartyWithUser(user, hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        return super
+            .listPatientsByHcParty(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    listPatientsOfHcParty(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    listPatientsOfHcPartyWithUser(user, hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection) {
+        return super
+            .listPatientsOfHcParty(hcPartyId, sortField, startKey, startDocumentId, limit, sortDirection)
+            .then((pl) => this.decrypt(user, pl.rows, false).then((dr) => Object.assign(pl, { rows: dr })));
+    }
+    mergeInto(toId, fromIds) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    mergeIntoWithUser(user, toId, fromIds) {
+        return super
+            .mergeInto(toId, fromIds)
+            .then((p) => this.decrypt(user, [p]))
+            .then((pats) => pats[0]);
+    }
+    modifyPatient(body) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    modifyPatientRaw(body) {
+        return super.modifyPatient(body);
+    }
+    modifyPatientWithUser(user, body) {
+        return body ? this.modifyAs(this.dataOwnerApi.getDataOwnerIdOf(user), body) : Promise.resolve(null);
+    }
+    modifyAs(dataOwner, body) {
+        return this.encryptAs(dataOwner, [_.cloneDeep(this.completeNames(body))])
+            .then((pats) => super.modifyPatient(pats[0]))
+            .then((p) => this.tryDecryptOrReturnOriginal(dataOwner, [p]))
+            .then((pats) => pats[0].entity);
+    }
+    modifyPatientReferral(patientId, referralId, start, end) {
+        throw new Error('Cannot call a method that returns contacts without providing a user for de/encryption');
+    }
+    modifyPatientReferralWithUser(user, patientId, referralId, start, end) {
+        return super
+            .modifyPatientReferral(patientId, referralId, start, end)
+            .then((p) => this.decrypt(user, [p]))
+            .then((pats) => pats[0]);
+    }
+    encrypt(user, pats) {
+        return this.encryptAs(this.dataOwnerApi.getDataOwnerIdOf(user), pats);
+    }
+    encryptAs(dataOwnerId, pats) {
+        return Promise.all(pats.map((p) => this.crypto.entities.tryEncryptEntity(p, dataOwnerId, this.encryptedKeys, true, false, (x) => new models.Patient(x))));
+    }
+    // If patient can't be decrypted returns patient with encrypted data.
+    decrypt(user, patients, fillDelegations = true) {
+        return this.tryDecryptOrReturnOriginal(this.dataOwnerApi.getDataOwnerIdOf(user), patients, fillDelegations).then((ps) => ps.map((p) => p.entity));
+    }
+    tryDecryptOrReturnOriginal(dataOwnerId, patients, fillDelegations = true) {
+        return Promise.all(patients.map((p) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.crypto.entities
+                .decryptEntity(p, dataOwnerId, (x) => new models.Patient(x))
+                .then((p) => {
+                if (p.entity.picture && !(p.entity.picture instanceof ArrayBuffer)) {
+                    return {
+                        entity: new models.Patient(Object.assign(Object.assign({}, p.entity), { picture: (0, ModelHelper_1.b64_2ab)(p.entity.picture) })),
+                        decrypted: p.decrypted,
+                    };
+                }
+                else
+                    return p;
+            });
+        })));
+    }
+    share(user, patId, ownerId, delegateIds, delegationTags, usingPost = false) {
+        const addDelegationsAndKeys = (dtos, markerPromise, delegateId, patient) => {
+            return dtos.reduce((p, x) => p.then(() => __awaiter(this, void 0, void 0, function* () {
+                const secretIds = yield this.crypto.entities.secretIdsOf(x, ownerId);
+                const encryptionKeys = yield this.crypto.entities.encryptionKeysOf(x, ownerId);
+                const parentIds = yield this.crypto.entities.owningEntityIdsOf(x, ownerId);
+                const updatedX = yield this.crypto.entities
+                    .entityWithExtendedEncryptedMetadata(x, delegateId, secretIds, encryptionKeys, parentIds, [])
+                    .catch((e) => {
+                    console.log(e);
+                    return x;
+                });
+                _.assign(x, updatedX);
+                return x;
+            })), markerPromise);
+        };
+        const allTags = _.uniq(_.flatMap(Object.values(delegationTags)));
+        // Determine which keys to share, depending on the delegation tag. For example, anonymousMedicalData only shares encryption keys and no delegations or secret foreign keys.
+        const shareDelegations = allTags.some((tag) => tag != 'anonymousMedicalInformation');
+        const shareEncryptionKeys = true;
+        const shareCryptedForeignKeys = allTags.some((tag) => tag != 'anonymousMedicalInformation');
+        // Anonymous sharing, will not change anything to the patient, only its contacts and health elements.
+        const shareAnonymously = allTags.every((tag) => tag == 'anonymousMedicalInformation');
+        return this.hcpartyApi.getHealthcareParty(ownerId).then((hcp) => {
+            const parentId = hcp.parentId;
+            const status = {
+                contacts: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('anonymousMedicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                forms: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                healthElements: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('anonymousMedicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                invoices: {
+                    success: allTags.includes('financialInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                documents: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                classifications: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                calendarItems: {
+                    success: allTags.includes('medicalInformation') || allTags.includes('all') ? false : null,
+                    error: null,
+                    modified: 0,
+                },
+                patient: { success: false, error: null, modified: 0 },
+            };
+            return (0, utils_1.retry)(() => this.getPatientWithUser(user, patId))
+                .then((patient) => patient.encryptionKeys && Object.keys(patient.encryptionKeys || {}).length
+                ? Promise.resolve(patient)
+                : this.crypto.entities
+                    .ensureEncryptionKeysInitialised(patient)
+                    .then((patient) => this.modifyPatientWithUser(user, patient)))
+                .then((patient) => __awaiter(this, void 0, void 0, function* () {
+                if (!patient) {
+                    status.patient = {
+                        success: false,
+                        error: new Error('Patient does not exist or cannot initialise encryption keys'),
+                    };
+                    return Promise.resolve({ patient: patient, statuses: status });
+                }
+                const delSfks = yield this.crypto.entities.secretIdsOf(patient, ownerId);
+                const ecKeys = yield this.crypto.entities.encryptionKeysOf(patient, ownerId);
+                return delSfks.length
+                    ? Promise.all([
+                        (0, utils_1.retry)(() => (usingPost
+                            ? this.helementApi.findHealthElementsDelegationsStubsByHCPartyPatientForeignKeysUsingPost(ownerId, _.uniq(delSfks))
+                            : this.helementApi.findHealthElementsDelegationsStubsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))).then((hes) => parentId
+                            ? (usingPost
+                                ? this.helementApi.findHealthElementsDelegationsStubsByHCPartyPatientForeignKeysUsingPost(parentId, _.uniq(delSfks))
+                                : this.helementApi.findHealthElementsDelegationsStubsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))).then((moreHes) => _.uniqBy(hes.concat(moreHes), 'id'))
+                            : hes)),
+                        (0, utils_1.retry)(() => (usingPost
+                            ? this.formApi.findFormsDelegationsStubsByHCPartyPatientForeignKeysUsingPost(ownerId, _.uniq(delSfks))
+                            : this.formApi.findFormsDelegationsStubsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))).then((frms) => parentId
+                            ? (usingPost
+                                ? this.formApi.findFormsDelegationsStubsByHCPartyPatientForeignKeysUsingPost(parentId, _.uniq(delSfks))
+                                : this.formApi.findFormsDelegationsStubsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))).then((moreFrms) => _.uniqBy(frms.concat(moreFrms), 'id'))
+                            : frms)),
+                        (0, utils_1.retry)(() => (usingPost
+                            ? this.contactApi.findByHCPartyPatientSecretFKeysUsingPost(ownerId, undefined, undefined, _.uniq(delSfks))
+                            : this.contactApi.findByHCPartyPatientSecretFKeys(ownerId, _.uniq(delSfks).join(','))).then((ctcs) => parentId
+                            ? (usingPost
+                                ? this.contactApi.findByHCPartyPatientSecretFKeysUsingPost(parentId, undefined, undefined, _.uniq(delSfks))
+                                : this.contactApi.findByHCPartyPatientSecretFKeys(parentId, _.uniq(delSfks).join(','))).then((moreCtcs) => _.uniqBy(ctcs.concat(moreCtcs), 'id'))
+                            : ctcs)),
+                        (0, utils_1.retry)(() => (usingPost
+                            ? this.invoiceApi.findInvoicesDelegationsStubsByHCPartyPatientForeignKeysUsingPost(ownerId, _.uniq(delSfks))
+                            : this.invoiceApi.findInvoicesDelegationsStubsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))).then((ivs) => parentId
+                            ? this.invoiceApi
+                                .findInvoicesDelegationsStubsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))
+                                .then((moreIvs) => _.uniqBy(ivs.concat(moreIvs), 'id'))
+                            : ivs)),
+                        (0, utils_1.retry)(() => this.classificationApi
+                            .findClassificationsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))
+                            .then((cls) => parentId
+                            ? this.classificationApi
+                                .findClassificationsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))
+                                .then((moreCls) => _.uniqBy(cls.concat(moreCls), 'id'))
+                            : cls)),
+                        (0, utils_1.retry)(() => (usingPost
+                            ? this.calendarItemApi.findByHCPartyPatientSecretFKeysArray(ownerId, _.uniq(delSfks))
+                            : this.calendarItemApi.findByHCPartyPatientSecretFKeys(ownerId, _.uniq(delSfks).join(','))).then((cls) => parentId
+                            ? (usingPost
+                                ? this.calendarItemApi.findByHCPartyPatientSecretFKeysArray(parentId, _.uniq(delSfks))
+                                : this.calendarItemApi.findByHCPartyPatientSecretFKeys(parentId, _.uniq(delSfks).join(','))).then((moreCls) => _.uniqBy(cls.concat(moreCls), 'id'))
+                            : cls)),
+                    ]).then(([hes, frms, ctcs, ivs, cls, cis]) => {
+                        const cloneKeysAndDelegations = function (x) {
+                            return {
+                                delegations: shareDelegations ? _.clone(x.delegations) : undefined,
+                                cryptedForeignKeys: shareCryptedForeignKeys ? _.clone(x.cryptedForeignKeys) : undefined,
+                                encryptionKeys: shareEncryptionKeys ? _.clone(x.encryptionKeys) : undefined,
+                            };
+                        };
+                        const ctcsStubs = ctcs.map((c) => (Object.assign({ id: c.id, rev: c.rev }, cloneKeysAndDelegations(c))));
+                        const oHes = hes.map((x) => _.assign(new models_1.IcureStub({}), x, cloneKeysAndDelegations(x)));
+                        const oFrms = frms.map((x) => _.assign(new models_1.IcureStub({}), x, cloneKeysAndDelegations(x)));
+                        const oCtcsStubs = ctcsStubs.map((x) => _.assign({}, x, cloneKeysAndDelegations(x)));
+                        const oIvs = ivs.map((x) => _.assign(new models_1.Invoice({}), x, cloneKeysAndDelegations(x)));
+                        const oCls = cls.map((x) => _.assign(new models_1.Classification({}), x, cloneKeysAndDelegations(x)));
+                        const oCis = cis.map((x) => _.assign(new models_1.CalendarItem({}), x, cloneKeysAndDelegations(x)));
+                        const docIds = {};
+                        ctcs.forEach((c) => c.services &&
+                            c.services.forEach((s) => s.content && Object.values(s.content).forEach((c) => c && c.documentId && (docIds[c.documentId] = 1))));
+                        return (0, utils_1.retry)(() => this.documentApi.getDocuments(new models_1.ListOfIds({ ids: Object.keys(docIds) }))).then((docs) => {
+                            const oDocs = docs.map((x) => _.assign({}, x, cloneKeysAndDelegations(x)));
+                            let markerPromise = Promise.resolve(null);
+                            delegateIds.forEach((delegateId) => {
+                                const tags = delegationTags[delegateId];
+                                markerPromise = markerPromise.then(() => __awaiter(this, void 0, void 0, function* () {
+                                    //Share patient
+                                    const updatedPatient = yield this.crypto.entities
+                                        .entityWithExtendedEncryptedMetadata(patient, delegateId, delSfks, ecKeys, [], [])
+                                        .catch((e) => {
+                                        console.log(e);
+                                        return patient;
+                                    });
+                                    return _.assign(patient, updatedPatient);
+                                }));
+                                (tags.includes('medicalInformation') || tags.includes('anonymousMedicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(hes, markerPromise, delegateId, patient));
+                                (tags.includes('medicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(frms, markerPromise, delegateId, patient));
+                                (tags.includes('medicalInformation') || tags.includes('anonymousMedicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(ctcsStubs, markerPromise, delegateId, patient));
+                                (tags.includes('medicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(cls, markerPromise, delegateId, patient));
+                                (tags.includes('medicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(cis, markerPromise, delegateId, patient));
+                                (tags.includes('financialInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(ivs, markerPromise, delegateId, patient));
+                                (tags.includes('medicalInformation') || tags.includes('all')) &&
+                                    (markerPromise = addDelegationsAndKeys(docs, markerPromise, delegateId, null));
+                            });
+                            return markerPromise
+                                .then(() => {
+                                //console.log("scd")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('anonymousMedicalInformation') || allTags.includes('all')) &&
+                                    ctcsStubs &&
+                                    ctcsStubs.length &&
+                                    !_.isEqual(oCtcsStubs, ctcsStubs) &&
+                                    this.contactApi
+                                        .setContactsDelegations(ctcsStubs)
+                                        .then(() => {
+                                        status.contacts.success = true;
+                                        status.contacts.modified += ctcsStubs.length;
+                                    })
+                                        .catch((e) => (status.contacts.error = e))) ||
+                                    Promise.resolve((status.contacts.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("shed")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('anonymousMedicalInformation') || allTags.includes('all')) &&
+                                    hes &&
+                                    hes.length &&
+                                    !_.isEqual(oHes, hes) &&
+                                    this.helementApi
+                                        .setHealthElementsDelegations(hes)
+                                        .then(() => {
+                                        status.healthElements.success = true;
+                                        status.healthElements.modified += hes.length;
+                                    })
+                                        .catch((e) => (status.healthElements.error = e))) ||
+                                    Promise.resolve((status.healthElements.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("sfd")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('all')) &&
+                                    frms &&
+                                    frms.length &&
+                                    !_.isEqual(oFrms, frms) &&
+                                    this.formApi
+                                        .setFormsDelegations(frms)
+                                        .then(() => {
+                                        status.forms.success = true;
+                                        status.forms.modified += frms.length;
+                                    })
+                                        .catch((e) => (status.forms.error = e))) ||
+                                    Promise.resolve((status.forms.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("sid")
+                                return (((allTags.includes('financialInformation') || allTags.includes('all')) &&
+                                    ivs &&
+                                    ivs.length &&
+                                    !_.isEqual(oIvs, ivs) &&
+                                    this.invoiceApi
+                                        .setInvoicesDelegations(ivs)
+                                        .then(() => {
+                                        status.invoices.success = true;
+                                        status.invoices.modified += ivs.length;
+                                    })
+                                        .catch((e) => (status.invoices.error = e))) ||
+                                    Promise.resolve((status.invoices.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("sdd")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('all')) &&
+                                    docs &&
+                                    docs.length &&
+                                    !_.isEqual(oDocs, docs) &&
+                                    this.documentApi
+                                        .setDocumentsDelegations(docs)
+                                        .then(() => {
+                                        status.documents.success = true;
+                                        status.documents.modified += docs.length;
+                                    })
+                                        .catch((e) => (status.documents.error = e))) ||
+                                    Promise.resolve((status.documents.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("scld")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('all')) &&
+                                    cls &&
+                                    cls.length &&
+                                    !_.isEqual(oCls, cls) &&
+                                    this.classificationApi
+                                        .setClassificationsDelegations(cls)
+                                        .then(() => {
+                                        status.classifications.success = true;
+                                        status.classifications.modified += cls.length;
+                                    })
+                                        .catch((e) => (status.classifications.error = e))) ||
+                                    Promise.resolve((status.classifications.success = true)));
+                            })
+                                .then(() => {
+                                //console.log("scid")
+                                return (((allTags.includes('medicalInformation') || allTags.includes('all')) &&
+                                    cis &&
+                                    cis.length &&
+                                    !_.isEqual(oCis, cis) &&
+                                    this.calendarItemApi
+                                        .setCalendarItemsDelegations(cis)
+                                        .then(() => {
+                                        status.calendarItems.success = true;
+                                        status.calendarItems.modified += cis.length;
+                                    })
+                                        .catch((e) => (status.calendarItems.error = e))) ||
+                                    Promise.resolve((status.calendarItems.success = true)));
+                            })
+                                .then(() => this.modifyPatientWithUser(user, patient))
+                                .then((p) => {
+                                status.patient.success = true;
+                                console.log(`c: ${status.contacts.modified}, he: ${status.healthElements.modified}, docs: ${status.documents.modified}, frms: ${status.forms.modified}, ivs: ${status.invoices.modified}, cis: ${status.calendarItems.modified}, cls: ${status.classifications.modified}`);
+                                return { patient: p, statuses: status };
+                            })
+                                .catch((e) => {
+                                status.patient.error = e;
+                                return { patient: patient, statuses: status };
+                            });
+                        });
+                    })
+                    : (allTags.includes('anonymousMedicalInformation')
+                        ? Promise.resolve(patient)
+                        : this.modifyPatientWithUser(user, _.assign(patient, {
+                            delegations: _.assign(patient.delegations, delegateIds
+                                .filter((id) => !patient.delegations || !patient.delegations[id]) //If there are delegations do not modify
+                                .reduce((acc, del) => Object.assign(acc, _.fromPairs([[del, []]])), patient.delegations || {})),
+                        })))
+                        .then((p) => {
+                        status.patient.success = true;
+                        return { patient: p, statuses: status };
+                    })
+                        .catch((e) => {
+                        status.patient.error = e;
+                        return { patient: patient, statuses: status };
+                    });
+            }));
+        });
+    }
+    export(user, patId, ownerId, usingPost = false) {
+        return this.hcpartyApi.getHealthcareParty(ownerId).then((hcp) => {
+            const parentId = hcp.parentId;
+            return (0, utils_1.retry)(() => this.getPatientWithUser(user, patId))
+                .then((patient) => patient.encryptionKeys && Object.keys(patient.encryptionKeys || {}).length
+                ? Promise.resolve(patient)
+                : this.crypto.entities
+                    .ensureEncryptionKeysInitialised(patient)
+                    .then((patient) => this.modifyPatientWithUser(user, patient)))
+                .then((patient) => __awaiter(this, void 0, void 0, function* () {
+                if (!patient) {
+                    return Promise.resolve({ id: patId });
+                }
+                const delSfks = yield this.crypto.entities.secretIdsOf(patient, ownerId);
+                return Promise.resolve().then(() => {
+                    return delSfks.length
+                        ? Promise.all([
+                            (0, utils_1.retry)(() => (usingPost
+                                ? this.helementApi.findByHCPartyPatientSecretFKeysArray(ownerId, _.uniq(delSfks))
+                                : this.helementApi.findByHCPartyPatientSecretFKeys(ownerId, _.uniq(delSfks).join(','))).then((hes) => parentId
+                                ? this.helementApi
+                                    .findByHCPartyPatientSecretFKeys(parentId, _.uniq(delSfks).join(','))
+                                    .then((moreHes) => _.uniqBy(hes.concat(moreHes), 'id'))
+                                : hes)),
+                            (0, utils_1.retry)(() => (usingPost
+                                ? this.formApi.findFormsByHCPartyPatientForeignKeysUsingPost(ownerId, undefined, undefined, undefined, _.uniq(delSfks))
+                                : this.formApi.findFormsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))).then((frms) => parentId
+                                ? (usingPost
+                                    ? this.formApi.findFormsByHCPartyPatientForeignKeysUsingPost(parentId, undefined, undefined, undefined, _.uniq(delSfks))
+                                    : this.formApi.findFormsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))).then((moreFrms) => _.uniqBy(frms.concat(moreFrms), 'id'))
+                                : frms)),
+                            (0, utils_1.retry)(() => (usingPost
+                                ? this.contactApi.findByHCPartyPatientSecretFKeysArray(ownerId, _.uniq(delSfks))
+                                : this.contactApi.findByHCPartyPatientSecretFKeys(ownerId, _.uniq(delSfks).join(','))).then((ctcs) => parentId
+                                ? (usingPost
+                                    ? this.contactApi.findByHCPartyPatientSecretFKeysArray(parentId, _.uniq(delSfks))
+                                    : this.contactApi.findByHCPartyPatientSecretFKeys(parentId, _.uniq(delSfks).join(','))).then((moreCtcs) => _.uniqBy(ctcs.concat(moreCtcs), 'id'))
+                                : ctcs)),
+                            (0, utils_1.retry)(() => (usingPost
+                                ? this.invoiceApi.findInvoicesByHCPartyPatientForeignKeysUsingPost(ownerId, _.uniq(delSfks))
+                                : this.invoiceApi.findInvoicesByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))).then((ivs) => parentId
+                                ? (usingPost
+                                    ? this.invoiceApi.findInvoicesByHCPartyPatientForeignKeysUsingPost(parentId, _.uniq(delSfks))
+                                    : this.invoiceApi.findInvoicesByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))).then((moreIvs) => _.uniqBy(ivs.concat(moreIvs), 'id'))
+                                : ivs)),
+                            (0, utils_1.retry)(() => this.classificationApi
+                                .findClassificationsByHCPartyPatientForeignKeys(ownerId, _.uniq(delSfks).join(','))
+                                .then((cls) => parentId
+                                ? this.classificationApi
+                                    .findClassificationsByHCPartyPatientForeignKeys(parentId, _.uniq(delSfks).join(','))
+                                    .then((moreCls) => _.uniqBy(cls.concat(moreCls), 'id'))
+                                : cls)),
+                            (0, utils_1.retry)(() => __awaiter(this, void 0, void 0, function* () {
+                                const delegationSFKs = _.uniq(delSfks).join(',');
+                                try {
+                                    let calendarItems = yield (usingPost
+                                        ? this.calendarItemApi.findByHCPartyPatientSecretFKeysArray(ownerId, _.uniq(delSfks))
+                                        : this.calendarItemApi.findByHCPartyPatientSecretFKeys(ownerId, _.uniq(delSfks).join(',')));
+                                    if (parentId) {
+                                        const moreCalendarItems = yield (usingPost
+                                            ? this.calendarItemApi.findByHCPartyPatientSecretFKeysArray(parentId, _.uniq(delSfks))
+                                            : this.calendarItemApi.findByHCPartyPatientSecretFKeys(parentId, _.uniq(delSfks).join(',')));
+                                        calendarItems = _.uniqBy(calendarItems.concat(moreCalendarItems), 'id');
+                                    }
+                                    return calendarItems;
+                                }
+                                catch (ex) {
+                                    console.log(`exception occured exporting calendarItem for ownerId: ${ownerId} - ${ex}`);
+                                    //throw ex
+                                }
+                            })),
+                        ]).then(([hes, frms, ctcs, ivs, cls, cis]) => {
+                            const docIds = {};
+                            ctcs.forEach((c) => c.services &&
+                                c.services.forEach((s) => s.content && Object.values(s.content).forEach((c) => c && c.documentId && (docIds[c.documentId] = 1))));
+                            return (0, utils_1.retry)(() => this.documentApi.getDocuments(new models_1.ListOfIds({ ids: Object.keys(docIds) }))).then((docs) => {
+                                return {
+                                    id: patId,
+                                    patient: patient,
+                                    contacts: ctcs,
+                                    forms: frms,
+                                    healthElements: hes,
+                                    invoices: ivs,
+                                    classifications: cls,
+                                    calItems: cis,
+                                    documents: docs,
+                                };
+                            });
+                        })
+                        : Promise.resolve({
+                            id: patId,
+                            patient: patient,
+                            contacts: [],
+                            forms: [],
+                            healthElements: [],
+                            invoices: [],
+                            classifications: [],
+                            calItems: [],
+                            documents: [],
+                        });
+                });
+            }));
+        });
+    }
+    checkInami(inami) {
+        const num_inami = inami.replace(new RegExp('[^(0-9)]', 'g'), '');
+        const checkDigit = num_inami.substring(6, 2);
+        const numSansCheck = num_inami.substring(0, 6);
+        let retour = false;
+        //modulo du niss
+        const modINAMI = parseInt(numSansCheck) % 97;
+        //obtention du num de check 97 - le resultat du mod
+        const checkDigit_2 = 97 - modINAMI;
+        if (parseInt(checkDigit) == checkDigit_2) {
+            retour = true;
+        }
+        return retour;
+    }
+    isValidSsin(ssin) {
+        ssin = ssin.replace(new RegExp('[^(0-9)]', 'g'), '');
+        let isValidNiss = false;
+        const normalNumber = /^[0-9][0-9](([0][0-9])|([1][0-2]))(([0-2][0-9])|([3][0-1]))(([0-9]{2}[1-9])|([0-9][1-9][0-9])|([1-9][0-9]{2}))(([0-8][0-9])|([9][0-7]))$/.test(ssin);
+        const bisNumber = /^[0-9][0-9](([2][0-9])|([3][0-2]))(([0-2][0-9])|([3][0-1]))[0-9]{3}(([0-8][0-9])|([9][0-7]))$/.test(ssin);
+        const terNumber = /^[0-9][0-9](([4][0-9])|([5][0-2]))(([0-2][0-9])|([3][0-1]))[0-9]{3}(([0-8][0-9])|([9][0-7]))$/.test(ssin);
+        if (normalNumber || bisNumber || terNumber) {
+            isValidNiss =
+                97 - (Number(ssin.substring(0, 9)) % 97) === Number(ssin.substring(9, 2))
+                    ? true
+                    : 97 - (Number('2' + ssin.substring(0, 9)) % 97) === Number(ssin.substring(9, 2));
+        }
+        return isValidNiss;
+    }
+    getPatientIdOfChildDocumentForHcpAndHcpParents(childDocument, hcpId) {
+        const _super = Object.create(null, {
+            getPatient: { get: () => super.getPatient }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const parentIdsArray = yield this.crypto.entities.owningEntityIdsOf(childDocument, hcpId);
+            const multipleParentIds = _.uniq(parentIdsArray).length > 1;
+            if (multipleParentIds) {
+                throw 'Child document with id ' + childDocument.id + ' contains multiple parent ids in its CFKs for hcpId: ' + hcpId;
+            }
+            const parentId = _.first(parentIdsArray);
+            if (!parentId) {
+                throw 'Parent id is empty in CFK of child document with id ' + childDocument.id + ' for hcpId: ' + hcpId;
+            }
+            let patient = yield _super.getPatient.call(this, parentId);
+            let mergeLevel = 0;
+            const maxMergeLevel = 10;
+            while (patient.mergeToPatientId) {
+                mergeLevel++;
+                if (mergeLevel === maxMergeLevel) {
+                    throw 'Too many merged levels for parent (Patient) of child document ' + childDocument.id + ' ; hcpId: ' + hcpId;
+                }
+                patient = yield _super.getPatient.call(this, patient.mergeToPatientId);
+            }
+            return patient.id;
+        });
+    }
+    /**
+     * Share an existing patient with other data owners, allowing them to access the non-encrypted data of the patient and optionally also
+     * the encrypted content.
+     * @param delegateId the id of the data owner which will be granted access to the patient.
+     * @param patient the patient to share.
+     * @param shareSecretIds the secret ids of the Patient that the delegate will be given access to. Allows the delegate to search for data where the
+     * shared Patient is the owning entity id.
+     * @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
+     * patient does not have encrypted content.
+     * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
+     * @return a promise which will contain the updated patient.
+     */
+    shareWith(delegateId, patient, shareSecretIds, 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(patient, delegateId, shareSecretIds, options.shareEncryptionKey, ShareMetadataBehaviour_1.ShareMetadataBehaviour.IF_AVAILABLE));
+        });
+    }
+    /**
+     * @param patient a patient
+     * @return all the decryptable secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptSecretIdsOf(patient) {
+        return this.crypto.entities.secretIdsOf(patient, undefined);
+    }
+    /**
+     * @param patient a patient
+     * @return the confidential secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptConfidentialSecretIdsOf(patient) {
+        return this.crypto.confidential.getConfidentialSecretIds(patient, undefined);
+    }
+    /**
+     * @param patient a patient
+     * @return the non-confidential secret ids of the patient, retrieved from the encrypted metadata. The result may be used to find entities where the
+     * patient is the 'owning entity', or in the {@link shareWith} method in order to share it with other data owners.
+     */
+    decryptNonConfidentialSecretIdsOf(patient) {
+        return this.crypto.confidential.getSecretIdsSharedWithParents(patient);
+    }
+}
+exports.IccPatientXApi = IccPatientXApi;
+//# sourceMappingURL=icc-patient-x-api.js.map