@webda/core 2.0.0-beta.2 → 2.0.1

package/lib/services/invitationservice.js

@@ -1,40 +1,27 @@
-"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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.InvitationParameters = void 0;
-const index_1 = require("../index");
-const service_1 = require("./service");
+import { Ident } from "../index.js";
+import { Inject, Service, ServiceParameters } from "./service.js";
 /**
  *
  */
-class InvitationParameters extends service_1.ServiceParameters {
+export class InvitationParameters extends ServiceParameters {
     constructor(params) {
-        var _a, _b, _c, _d;
         super(params);
-        (_a = this.authenticationService) !== null && _a !== void 0 ? _a : (this.authenticationService = "Authentication");
+        this.authenticationService ?? (this.authenticationService = "Authentication");
         if (typeof this.mapFields === "string") {
             this.mapFields = this.mapFields.split(",");
         }
-        (_b = this.mapFields) !== null && _b !== void 0 ? _b : (this.mapFields = []);
-        (_c = this.multiple) !== null && _c !== void 0 ? _c : (this.multiple = true);
+        this.mapFields ?? (this.mapFields = []);
+        this.multiple ?? (this.multiple = true);
         if (!this.attribute.startsWith("_")) {
             throw new Error(`Attribute '${this.attribute}' needs to start with a _ to be only modified by server`);
         }
-        (_d = this.pendingAttribute) !== null && _d !== void 0 ? _d : (this.pendingAttribute = `${this.attribute}Pending`);
+        this.pendingAttribute ?? (this.pendingAttribute = `${this.attribute}Pending`);
         if (!this.pendingAttribute.startsWith("_")) {
             throw new Error(`Attribute '${this.pendingAttribute}' needs to start with a _ to be only modified by server`);
         }
@@ -43,7 +30,6 @@ class InvitationParameters extends service_1.ServiceParameters {
         }
     }
 }
-exports.InvitationParameters = InvitationParameters;
 /**
  * Allow to use invitation on AclModel
  *
@@ -52,7 +38,7 @@ exports.InvitationParameters = InvitationParameters;
  *
  * @WebdaModda
  */
-class InvitationService extends service_1.Service {
+export default class InvitationService extends Service {
     /**
      * @inheritdoc
      */
@@ -68,61 +54,56 @@ class InvitationService extends service_1.Service {
         this.authenticationService.on("Authentication.Register", (evt) => this.registrationListener(evt));
         const url = this.modelStore.getParameters().expose.url;
         this.addRoute(`${url}/{uuid}/invitations`, ["GET", "POST", "PUT", "DELETE"], this.invite);
+        return this;
     }
     /**
      * @inheritdoc
      */
-    init() {
-        const _super = Object.create(null, {
-            init: { get: () => super.init }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.init.call(this);
-            if (this.parameters.notification &&
-                !(yield this.notificationService.hasNotification(this.parameters.notification))) {
-                throw new Error(`Email template should exist`);
-            }
-        });
+    async init() {
+        await super.init();
+        if (this.parameters.notification &&
+            !(await this.notificationService.hasNotification(this.parameters.notification))) {
+            throw new Error(`Email template should exist`);
+        }
+        return this;
     }
     /**
      * Accept or refuse for an invitation
      * @param ctx
      * @param model
      */
-    answerInvitation(ctx, model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let body = yield ctx.getRequestBody();
-            // Need to specify if you accept or not
-            if (typeof body.accept !== "boolean") {
-                throw 400;
-            }
-            // Invitation on the model is gone
-            if (model === undefined) {
-                yield this.removeInvitationFromUser(ctx.getCurrentUserId(), ctx.getParameters().uuid);
-                throw 410;
-            }
-            const user = yield ctx.getCurrentUser();
-            let metadata = undefined;
-            user.getIdents().forEach(i => {
-                if (model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`]) {
-                    metadata = model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`];
-                    delete model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`];
-                }
-            });
-            if (model[this.parameters.pendingAttribute][`user_${user.getUuid()}`]) {
-                metadata = model[this.parameters.pendingAttribute][`user_${user.getUuid()}`];
-                delete model[this.parameters.pendingAttribute][`user_${user.getUuid()}`];
-            }
-            if (metadata && body.accept) {
-                model[this.parameters.attribute][user.getUuid()] = metadata;
+    async answerInvitation(ctx, model) {
+        let body = await ctx.getRequestBody();
+        // Need to specify if you accept or not
+        if (typeof body.accept !== "boolean") {
+            throw 400;
+        }
+        // Invitation on the model is gone
+        if (model === undefined) {
+            await this.removeInvitationFromUser(ctx.getCurrentUserId(), ctx.getParameters().uuid);
+            throw 410;
+        }
+        const user = await ctx.getCurrentUser();
+        let metadata = undefined;
+        user.getIdents().forEach(i => {
+            if (model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`]) {
+                metadata = model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`];
+                delete model[this.parameters.pendingAttribute][`ident_${i.getUuid()}`];
             }
-            yield this.updateModel(model);
-            this.emit("Invitation.Accepted", {
-                metadata,
-                model,
-                context: ctx,
-                accept: body.accept
-            });
+        });
+        if (model[this.parameters.pendingAttribute][`user_${user.getUuid()}`]) {
+            metadata = model[this.parameters.pendingAttribute][`user_${user.getUuid()}`];
+            delete model[this.parameters.pendingAttribute][`user_${user.getUuid()}`];
+        }
+        if (metadata && body.accept) {
+            model[this.parameters.attribute][user.getUuid()] = metadata;
+        }
+        await this.updateModel(model);
+        this.emit("Invitation.Accepted", {
+            metadata,
+            model,
+            context: ctx,
+            accept: body.accept
         });
     }
     /**
@@ -130,12 +111,10 @@ class InvitationService extends service_1.Service {
      *
      * @param model
      */
-    updateModel(model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield model.update({
-                [this.parameters.attribute]: model[this.parameters.attribute],
-                [this.parameters.pendingAttribute]: model[this.parameters.pendingAttribute]
-            });
+    async updateModel(model) {
+        await model.patch({
+            [this.parameters.attribute]: model[this.parameters.attribute],
+            [this.parameters.pendingAttribute]: model[this.parameters.pendingAttribute]
         });
     }
     /**
@@ -143,75 +122,70 @@ class InvitationService extends service_1.Service {
      * @param ctx
      * @param model
      */
-    uninvite(ctx, model) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const body = yield ctx.getRequestBody();
-            (_a = body.users) !== null && _a !== void 0 ? _a : (body.users = []);
-            (_b = body.idents) !== null && _b !== void 0 ? _b : (body.idents = []);
-            const promises = [];
-            let invitedIdents = [];
-            let invitedUsers = [];
-            for (const ident of body.idents) {
-                if (model[this.parameters.pendingAttribute][`ident_${ident}`]) {
-                    // Remove from pending on the object
-                    delete model[this.parameters.pendingAttribute][`ident_${ident}`];
-                    // Remove from pending from the invitation store
-                    promises.push(this.invitationStore.removeAttribute(`${ident}_${this.getName()}`, this.getInvitationAttribute(model.getUuid())));
-                    invitedIdents.push(ident);
-                }
-                else {
-                    // Remove user
-                    promises.push((() => __awaiter(this, void 0, void 0, function* () {
-                        const id = yield this.authenticationService.getIdentStore().get(ident);
-                        if (id && id.getUser()) {
-                            delete model[this.parameters.attribute][id.getUser()];
-                            yield this.removeInvitationFromUser(id.getUser(), model.getUuid());
-                            invitedUsers.push(id.getUser());
-                        }
-                    }))());
-                }
+    async uninvite(ctx, model) {
+        const body = await ctx.getRequestBody();
+        body.users ?? (body.users = []);
+        body.idents ?? (body.idents = []);
+        const promises = [];
+        let invitedIdents = [];
+        let invitedUsers = [];
+        for (const ident of body.idents) {
+            if (model[this.parameters.pendingAttribute][`ident_${ident}`]) {
+                // Remove from pending on the object
+                delete model[this.parameters.pendingAttribute][`ident_${ident}`];
+                // Remove from pending from the invitation store
+                promises.push(this.invitationStore.removeAttribute(`${ident}_${this.getName()}`, this.getInvitationAttribute(model.getUuid())));
+                invitedIdents.push(ident);
             }
-            for (const user of body.users) {
-                if (model[this.parameters.pendingAttribute][`user_${user}`]) {
-                    delete model[this.parameters.pendingAttribute][`user_${user}`];
-                }
-                else if (model[this.parameters.attribute][user]) {
-                    delete model[this.parameters.attribute][user];
-                }
-                promises.push(this.removeInvitationFromUser(user, model.getUuid()));
-                invitedUsers.push(user);
+            else {
+                // Remove user
+                promises.push((async () => {
+                    const id = await this.authenticationService.getIdentStore().get(ident);
+                    if (id && id.getUser()) {
+                        delete model[this.parameters.attribute][id.getUser()];
+                        await this.removeInvitationFromUser(id.getUser(), model.getUuid());
+                        invitedUsers.push(id.getUser());
+                    }
+                })());
             }
-            yield Promise.all(promises);
-            //
-            yield this.updateModel(model);
-            this.emit("Invitation.Removed", {
-                metadata: body.metadata,
-                users: invitedUsers,
-                idents: invitedIdents,
-                model,
-                context: ctx
-            });
+        }
+        for (const user of body.users) {
+            if (model[this.parameters.pendingAttribute][`user_${user}`]) {
+                delete model[this.parameters.pendingAttribute][`user_${user}`];
+            }
+            else if (model[this.parameters.attribute][user]) {
+                delete model[this.parameters.attribute][user];
+            }
+            promises.push(this.removeInvitationFromUser(user, model.getUuid()));
+            invitedUsers.push(user);
+        }
+        await Promise.all(promises);
+        //
+        await this.updateModel(model);
+        this.emit("Invitation.Removed", {
+            metadata: body.metadata,
+            users: invitedUsers,
+            idents: invitedIdents,
+            model,
+            context: ctx
         });
     }
     /**
      * Remove a model invitation from user
      * @param user
      */
-    removeInvitationFromUser(user, model) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userModel = yield this.authenticationService.getUserStore().get(user);
-            let index = 0;
-            for (let invit of userModel[this.parameters.mapAttribute] || []) {
-                if (invit.model === model) {
-                    yield this.authenticationService
-                        .getUserStore()
-                        .deleteItemFromCollection(user, this.parameters.mapAttribute, index, model, "model");
-                    return;
-                }
-                index++;
+    async removeInvitationFromUser(user, model) {
+        let userModel = await this.authenticationService.getUserStore().get(user);
+        let index = 0;
+        for (let invit of userModel[this.parameters.mapAttribute] || []) {
+            if (invit.model === model) {
+                await this.authenticationService
+                    .getUserStore()
+                    .deleteItemFromCollection(user, this.parameters.mapAttribute, index, model, "model");
+                return;
             }
-        });
+            index++;
+        }
     }
     /**
      * Handle invitations all methods
@@ -219,152 +193,143 @@ class InvitationService extends service_1.Service {
      * @param ctx
      * @returns
      */
-    invite(ctx) {
-        var _a, _b, _c, _d;
-        var _e, _f, _g;
-        return __awaiter(this, void 0, void 0, function* () {
-            let model = yield this.modelStore.get(ctx.getParameters().uuid);
-            if (ctx.getHttpContext().getMethod() === "PUT") {
-                return this.answerInvitation(ctx, model);
-            }
-            let inviter = yield ctx.getCurrentUser();
-            if (!model) {
-                throw 404;
-            }
-            (_a = model[_e = this.parameters.attribute]) !== null && _a !== void 0 ? _a : (model[_e] = {});
-            (_b = model[_f = this.parameters.pendingAttribute]) !== null && _b !== void 0 ? _b : (model[_f] = {});
-            if (ctx.getHttpContext().getMethod() === "DELETE") {
-                yield model.canAct(ctx, "uninvite");
-                return this.uninvite(ctx, model);
-            }
-            yield model.canAct(ctx, "invite");
-            // Retrieve invitation useful when invitation are hidden with a __
-            if (ctx.getHttpContext().getMethod() === "GET") {
-                ctx.write(model[this.parameters.pendingAttribute] || {});
-                return;
-            }
-            const body = yield ctx.getRequestBody();
-            // For each ident
-            const identsStore = this.authenticationService.getIdentStore();
-            // Load all idents with orignal
-            const invitations = yield Promise.all((body.idents || []).map((i) => __awaiter(this, void 0, void 0, function* () {
-                return ({
-                    ident: yield identsStore.get(i),
-                    invitation: i
-                });
-            })));
-            let invitedIdents = [];
-            let invitedUsers = [];
-            let promises = [];
-            const metadata = {};
-            this.parameters.mapFields.forEach(f => (metadata[f] = model[f]));
-            for (const invitation of invitations) {
-                // User is known
-                if (invitation.ident) {
-                    if (this.parameters.autoAccept) {
-                        model[this.parameters.attribute][invitation.ident.getUser()] = body.metadata;
-                    }
-                    else if (!model[this.parameters.attribute][invitation.ident.getUser()]) {
-                        // Add to the user
-                        model[this.parameters.pendingAttribute][`user_${invitation.ident.getUser()}`] = body.metadata;
-                    }
-                    promises.push((() => __awaiter(this, void 0, void 0, function* () {
-                        const user = yield this.authenticationService.getUserStore().get(invitation.ident.getUser());
-                        invitedUsers.push(user);
-                        yield this.addInvitationToUser(model, user, inviter, metadata, body.notification);
-                    }))());
-                    continue;
-                }
-                // User is unknown to the platform
-                invitedIdents.push(invitation.invitation);
-                let invitUuid = `${invitation.invitation}_${this.getName()}`;
-                (_c = model[_g = this.parameters.pendingAttribute]) !== null && _c !== void 0 ? _c : (model[_g] = {});
-                model[this.parameters.pendingAttribute][`ident_${invitation.invitation}`] = body.metadata;
-                const invitInfo = {
-                    inviter: inviter.toPublicEntry(),
-                    metadata: body.metadata
-                };
-                if (yield this.invitationStore.exists(invitUuid)) {
-                    promises.push(this.invitationStore.setAttribute(invitUuid, this.getInvitationAttribute(model.getUuid()), invitInfo));
-                }
-                else {
-                    promises.push(this.invitationStore.save({
-                        uuid: invitUuid,
-                        [this.getInvitationAttribute(model.getUuid())]: invitInfo
-                    }));
-                }
-                // Notify ident
-                let ident = invitation.invitation.split("_");
-                yield this.sendNotification(index_1.Ident.init(ident.pop(), ident.join("_")), {
-                    model,
-                    metadata,
-                    notification: body.notification,
-                    inviter: inviter.toPublicEntry(),
-                    pending: !this.parameters.autoAccept,
-                    registered: true
-                });
-            }
-            // Check user direct invite
-            (_d = body.users) !== null && _d !== void 0 ? _d : (body.users = []);
-            promises.push(...body.users.map((u) => __awaiter(this, void 0, void 0, function* () {
-                let user = yield this.authenticationService.getUserStore().get(u);
-                if (!user) {
-                    return;
-                }
+    async invite(ctx) {
+        var _a, _b, _c;
+        let model = await this.modelStore.get(ctx.getParameters().uuid);
+        if (ctx.getHttpContext().getMethod() === "PUT") {
+            return this.answerInvitation(ctx, model);
+        }
+        let inviter = await ctx.getCurrentUser();
+        if (!model) {
+            throw 404;
+        }
+        model[_a = this.parameters.attribute] ?? (model[_a] = {});
+        model[_b = this.parameters.pendingAttribute] ?? (model[_b] = {});
+        if (ctx.getHttpContext().getMethod() === "DELETE") {
+            await model.canAct(ctx, "uninvite");
+            return this.uninvite(ctx, model);
+        }
+        await model.canAct(ctx, "invite");
+        // Retrieve invitation useful when invitation are hidden with a __
+        if (ctx.getHttpContext().getMethod() === "GET") {
+            ctx.write(model[this.parameters.pendingAttribute] || {});
+            return;
+        }
+        const body = await ctx.getRequestBody();
+        // For each ident
+        const identsStore = this.authenticationService.getIdentStore();
+        // Load all idents with orignal
+        const invitations = await Promise.all((body.idents || []).map(async (i) => ({
+            ident: await identsStore.get(i),
+            invitation: i
+        })));
+        let invitedIdents = [];
+        let invitedUsers = [];
+        let promises = [];
+        const metadata = {};
+        this.parameters.mapFields.forEach(f => (metadata[f] = model[f]));
+        for (const invitation of invitations) {
+            // User is known
+            if (invitation.ident) {
                 if (this.parameters.autoAccept) {
-                    model[this.parameters.attribute][u] = body.metadata;
+                    model[this.parameters.attribute][invitation.ident.getUser()] = body.metadata;
                 }
-                else if (!model[this.parameters.attribute][u]) {
-                    model[this.parameters.pendingAttribute][`user_${u}`] = body.metadata;
+                else if (!model[this.parameters.attribute][invitation.ident.getUser()]) {
+                    // Add to the user
+                    model[this.parameters.pendingAttribute][`user_${invitation.ident.getUser()}`] = body.metadata;
                 }
-                invitedUsers.push(user);
-                yield this.addInvitationToUser(model, user, inviter, metadata, body.notification);
-            })));
-            yield Promise.all(promises);
-            // Update model now
-            yield this.updateModel(model);
-            this.emit("Invitation.Sent", {
-                metadata: body.metadata,
-                notification: body.notification,
-                users: invitedUsers,
-                idents: invitedIdents,
-                model,
-                context: ctx
-            });
-        });
-    }
-    addInvitationToUser(model, user, inviter, metadata, notification = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((user[this.parameters.mapAttribute] || []).filter(p => p.model === model.getUuid()).length) {
-                return;
+                promises.push((async () => {
+                    const user = await this.authenticationService.getUserStore().get(invitation.ident.getUser());
+                    invitedUsers.push(user);
+                    await this.addInvitationToUser(model, user, inviter, metadata, body.notification);
+                })());
+                continue;
             }
-            yield this.authenticationService
-                .getUserStore()
-                .upsertItemToCollection(user.getUuid(), this.parameters.mapAttribute, {
-                model: model.getUuid(),
-                metadata,
+            // User is unknown to the platform
+            invitedIdents.push(invitation.invitation);
+            let invitUuid = `${invitation.invitation}_${this.getName()}`;
+            model[_c = this.parameters.pendingAttribute] ?? (model[_c] = {});
+            model[this.parameters.pendingAttribute][`ident_${invitation.invitation}`] = body.metadata;
+            const invitInfo = {
                 inviter: inviter.toPublicEntry(),
-                pending: !this.parameters.autoAccept
-            });
-            // Notify user
-            yield this.sendNotification(user, {
+                metadata: body.metadata
+            };
+            if (await this.invitationStore.exists(invitUuid)) {
+                promises.push(this.invitationStore.setAttribute(invitUuid, this.getInvitationAttribute(model.getUuid()), invitInfo));
+            }
+            else {
+                promises.push(this.invitationStore.save({
+                    uuid: invitUuid,
+                    [this.getInvitationAttribute(model.getUuid())]: invitInfo
+                }));
+            }
+            // Notify ident
+            let ident = invitation.invitation.split("_");
+            await this.sendNotification(Ident.init(ident.pop(), ident.join("_")), {
                 model,
                 metadata,
-                notification,
+                notification: body.notification,
                 inviter: inviter.toPublicEntry(),
                 pending: !this.parameters.autoAccept,
                 registered: true
             });
-        });
-    }
-    sendNotification(user, replacements) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.parameters.notification) {
+        }
+        // Check user direct invite
+        body.users ?? (body.users = []);
+        promises.push(...body.users.map(async (u) => {
+            let user = await this.authenticationService.getUserStore().get(u);
+            if (!user) {
                 return;
             }
-            yield this.notificationService.sendNotification(user, this.parameters.notification, replacements);
+            if (this.parameters.autoAccept) {
+                model[this.parameters.attribute][u] = body.metadata;
+            }
+            else if (!model[this.parameters.attribute][u]) {
+                model[this.parameters.pendingAttribute][`user_${u}`] = body.metadata;
+            }
+            invitedUsers.push(user);
+            await this.addInvitationToUser(model, user, inviter, metadata, body.notification);
+        }));
+        await Promise.all(promises);
+        // Update model now
+        await this.updateModel(model);
+        this.emit("Invitation.Sent", {
+            metadata: body.metadata,
+            notification: body.notification,
+            users: invitedUsers,
+            idents: invitedIdents,
+            model,
+            context: ctx
         });
     }
+    async addInvitationToUser(model, user, inviter, metadata, notification = {}) {
+        if ((user[this.parameters.mapAttribute] || []).filter(p => p.model === model.getUuid()).length) {
+            return;
+        }
+        await this.authenticationService
+            .getUserStore()
+            .upsertItemToCollection(user.getUuid(), this.parameters.mapAttribute, {
+            model: model.getUuid(),
+            metadata,
+            inviter: inviter.toPublicEntry(),
+            pending: !this.parameters.autoAccept
+        });
+        // Notify user
+        await this.sendNotification(user, {
+            model,
+            metadata,
+            notification,
+            inviter: inviter.toPublicEntry(),
+            pending: !this.parameters.autoAccept,
+            registered: true
+        });
+    }
+    async sendNotification(user, replacements) {
+        if (!this.parameters.notification) {
+            return;
+        }
+        await this.notificationService.sendNotification(user, this.parameters.notification, replacements);
+    }
     /**
      * Return which attribute would be used to store the invitation on ident invitation object
      * @param uuid
@@ -379,66 +344,63 @@ class InvitationService extends service_1.Service {
      * @param evt
      * @returns
      */
-    registrationListener(evt) {
-        var _a;
-        var _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            let uuid = `${evt.identId}_${this.getName()}`;
-            const invitations = yield this.invitationStore.get(uuid);
-            if (!invitations) {
-                return;
-            }
-            this.log("DEBUG", `Resolving invitation for ident ${evt.identId}`);
-            // Load all models invited too
-            const infos = yield Promise.all(Object.keys(invitations)
-                .filter(k => k.startsWith("invit_"))
-                .map((k) => __awaiter(this, void 0, void 0, function* () {
-                return (Object.assign(Object.assign({}, invitations[k]), { model: yield this.modelStore.get(k.substring(6)) }));
-            })));
-            // autoAccept is on so move to __acls
-            const promises = [];
-            // If autoAccept is false, just copy the pending invitation in the user
-            (_a = (_b = evt.user)[_c = this.parameters.mapAttribute]) !== null && _a !== void 0 ? _a : (_b[_c] = []);
-            evt.user[this.parameters.mapAttribute].push(...infos
-                .filter(m => m.model !== undefined)
-                .map(m => {
-                const metadata = {};
-                this.parameters.mapFields.forEach(f => (metadata[f] = m.model[f]));
-                return {
-                    model: m.model.getUuid(),
-                    metadata,
-                    inviter: m.inviter,
-                    pending: !this.parameters.autoAccept
-                };
-            }));
-            if (this.parameters.autoAccept) {
-                for (const info of infos) {
-                    if (!info.model) {
-                        continue;
-                    }
-                    // Set the metadata
-                    info.model[this.parameters.attribute][evt.user.getUuid()] = info.metadata;
-                    // Remove pending
-                    delete info.model[this.parameters.pendingAttribute][`ident_${evt.identId}`];
-                    promises.push(this.updateModel(info.model));
+    async registrationListener(evt) {
+        var _a, _b;
+        let uuid = `${evt.identId}_${this.getName()}`;
+        const invitations = await this.invitationStore.get(uuid);
+        if (!invitations) {
+            return;
+        }
+        this.log("DEBUG", `Resolving invitation for ident ${evt.identId}`);
+        // Load all models invited too
+        const infos = await Promise.all(Object.keys(invitations)
+            .filter(k => k.startsWith("invit_"))
+            .map(async (k) => ({
+            ...invitations[k],
+            model: await this.modelStore.get(k.substring(6))
+        })));
+        // autoAccept is on so move to __acls
+        const promises = [];
+        // If autoAccept is false, just copy the pending invitation in the user
+        (_a = evt.user)[_b = this.parameters.mapAttribute] ?? (_a[_b] = []);
+        evt.user[this.parameters.mapAttribute].push(...infos
+            .filter(m => m.model !== undefined)
+            .map(m => {
+            const metadata = {};
+            this.parameters.mapFields.forEach(f => (metadata[f] = m.model[f]));
+            return {
+                model: m.model.getUuid(),
+                metadata,
+                inviter: m.inviter,
+                pending: !this.parameters.autoAccept
+            };
+        }));
+        if (this.parameters.autoAccept) {
+            for (const info of infos) {
+                if (!info.model) {
+                    continue;
                 }
+                // Set the metadata
+                info.model[this.parameters.attribute][evt.user.getUuid()] = info.metadata;
+                // Remove pending
+                delete info.model[this.parameters.pendingAttribute][`ident_${evt.identId}`];
+                promises.push(this.updateModel(info.model));
             }
-            promises.push(invitations.delete());
-            yield Promise.all(promises);
-        });
+        }
+        promises.push(invitations.delete());
+        await Promise.all(promises);
     }
 }
 __decorate([
-    (0, service_1.Inject)("params:authenticationService")
+    Inject("params:authenticationService")
 ], InvitationService.prototype, "authenticationService", void 0);
 __decorate([
-    (0, service_1.Inject)("params:notificationService", true)
+    Inject("params:notificationService", true)
 ], InvitationService.prototype, "notificationService", void 0);
 __decorate([
-    (0, service_1.Inject)("params:invitationStore")
+    Inject("params:invitationStore")
 ], InvitationService.prototype, "invitationStore", void 0);
 __decorate([
-    (0, service_1.Inject)("params:modelStore")
+    Inject("params:modelStore")
 ], InvitationService.prototype, "modelStore", void 0);
-exports.default = InvitationService;
 //# sourceMappingURL=invitationservice.js.map