@3wks/gae-node-nestjs/dist/auth/invite-user.service.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const common_1 = require("@nestjs/common");
const uuidv4 = require("uuid/v4");
const configuration_1 = require("../configuration");
const transactional_1 = require("../datastore/transactional");
const logging_1 = require("../gcloud/logging");
const index_1 = require("../index");
const invite_1 = require("../mail-templates/invite");
const mail_sender_1 = require("../mail/mail.sender");
const arrays_1 = require("../util/arrays");
const auth_repository_1 = require("./auth.repository");
const auth_service_1 = require("./auth.service");
exports.DEFAULT_INVITE_CODE_EXPIRY = 7 * 24 * 60 * 60 * 1000;
const DEFAULT_INVITE_CODE_EXPIRY_EMAIL_COPY = '7 days';
const DEFAULT_INVITATION_EMAIL_COPY = 'You have been invited as a new user.';
let InviteUserService = class InviteUserService {
    constructor(authRepository, mailSender, configuration, userService, userInviteRepository) {
        this.authRepository = authRepository;
        this.mailSender = mailSender;
        this.configuration = configuration;
        this.userService = userService;
        this.userInviteRepository = userInviteRepository;
        this.getActivationExpiryInMillis = () => {
            return this.configuration.auth.local && this.configuration.auth.local.activationExpiryInMinutes
                ? this.configuration.auth.local.activationExpiryInMinutes * 60 * 1000
                : exports.DEFAULT_INVITE_CODE_EXPIRY;
        };
        this.getActivationExpiryEmailCopy = () => !(this.configuration.auth.local && this.configuration.auth.local.activationExpiryInMinutes)
            ? DEFAULT_INVITE_CODE_EXPIRY_EMAIL_COPY
            : this.configuration.auth.local.activationExpiryEmailCopy;
        this.getInvitationCopy = () => !(this.configuration.auth.local && this.configuration.auth.local.invitationEmailCopy)
            ? DEFAULT_INVITATION_EMAIL_COPY
            : this.configuration.auth.local.invitationEmailCopy;
        this.logger = logging_1.createLogger('invite-user-service');
    }
    async inviteUserIfRequired(context, request) {
        return this.inviteUserInternal(context, request, false);
    }
    async inviteUser(context, request) {
        return this.inviteUserInternal(context, request, true);
    }
    async getInvitedUser(context, code) {
        const invite = await this.userInviteRepository.get(context, code);
        if (!invite) {
            return;
        }
        const activationExpiry = this.getActivationExpiryInMillis();
        if (Date.now() - invite.createdAt.getTime() > activationExpiry) {
            this.logger.info(`User invite for ${invite.email} has expired. Was created ${invite.createdAt}.`);
            throw new Error('Account activation code expired');
        }
        return this.userService.get(context, invite.userId);
    }
    async reInviteForUserId(context, userId) {
        this.logger.info(`Re Inviting user with id: ${userId}`);
        const existingInvite = await this.getUserInviteForUserId(context, userId);
        if (existingInvite) {
            return this.reInviteUser(context, existingInvite);
        }
        else {
            throw new Error('No user invites found.');
        }
    }
    async getUserInviteForUserId(context, userId) {
        const [existingInvites] = await this.userInviteRepository.query(context, {
            filters: {
                userId,
            },
            limit: 1,
        });
        this.logger.info(`Existing Invites ${existingInvites}`);
        if (existingInvites && existingInvites.length > 0) {
            return existingInvites[0];
        }
        else {
            return undefined;
        }
    }
    async reInviteUser(context, existingInvite) {
        const user = await this.userService.getByEmail(context, existingInvite.email);
        if (!user) {
            throw new Error('User not found');
        }
        const newInvite = await this.userInviteRepository.save(context, {
            id: uuidv4(),
            email: existingInvite.email,
            createdAt: new Date(),
            roles: existingInvite.roles,
            userId: existingInvite.userId,
        });
        await this.userInviteRepository.delete(context, existingInvite.id);
        const activateLink = await this.sendActivationEmail(context, newInvite.email, newInvite.id, false);
        return { user, inviteId: newInvite.id, activateLink };
    }
    async inviteUserInternal(context, request, validateNew) {
        const { email, roles } = request;
        this.logger.info(`Inviting user with email: ${email}, roles: ${roles}, validateNew: ${validateNew}`);
        if (roles.includes('super')) {
            throw new Error('Cannot assign super role to users');
        }
        const auth = await this.authRepository.get(context, email);
        if (validateNew && auth) {
            throw new Error('Email already exists');
        }
        let user = await this.userService.getByEmail(context, email);
        if (!user) {
            user = await this.userService.create(context, {
                email,
                name: request.name,
                enabled: false,
            });
        }
        if (auth) {
            this.logger.info(`User with email ${email} already has a login so does not need to be invited`);
            const updatedUser = await this.userService.update(context, user.id, {
                roles: arrays_1.unique(user.roles, ...roles),
                enabled: true,
            });
            return { user: updatedUser };
        }
        else {
            const inviteId = uuidv4();
            await this.userInviteRepository.save(context, {
                id: inviteId,
                email,
                createdAt: new Date(),
                roles,
                userId: user.id,
            });
            const activateLink = await this.sendActivationEmail(context, email, inviteId, request.skipEmail);
            return { user, inviteId, activateLink };
        }
    }
    async sendActivationEmail(context, email, inviteId, skipEmail) {
        const activateLink = `${this.configuration.host}/activate/${inviteId}`;
        if (skipEmail) {
            this.logger.info('Skipping sending invitation email based on request option');
            return activateLink;
        }
        this.logger.info(`Sending invitation email to ${email} with link ${activateLink}`);
        const title = 'Activate your account';
        await this.mailSender.send(context, {
            to: email,
            subject: title,
            html: invite_1.userInviteEmail(title, activateLink, this.getInvitationCopy(), this.getActivationExpiryEmailCopy()),
        });
        return activateLink;
    }
    async checkActivationCode(context, code) {
        const invite = await this.userInviteRepository.get(context, code);
        return this.checkInvite(context, invite);
    }
    async activateAccount(context, code, name, password) {
        const invite = await this.userInviteRepository.get(context, code);
        const err = await this.checkInvite(context, invite);
        if (err) {
            throw new Error(err);
        }
        const user = await this.userService.update(context, invite.userId, {
            name,
            roles: invite.roles,
            enabled: true,
        });
        this.logger.info(`Accepting invitation and activating account for email ${user.email}, code ${code}, name ${name}`);
        await this.authRepository.save(context, {
            id: invite.email,
            type: 'password',
            password: await auth_service_1.hashPassword(password),
            userId: user.id,
        });
        await this.userInviteRepository.delete(context, code);
        return user;
    }
    async checkInvite(context, invite) {
        if (!invite) {
            return 'This activation code is no longer available. Please use the \'Activate Account\' link in the most recent activation email you have received. If you\'re still experiencing problems please contact your administrator.';
        }
        const activationExpiry = this.getActivationExpiryInMillis();
        if (Date.now() - invite.createdAt.getTime() > activationExpiry) {
            return 'Sorry, your activation code has expired. Please contact your administrator';
        }
        const auth = await this.authRepository.get(context, invite.email);
        if (auth) {
            return 'Account already registered';
        }
        return null;
    }
};
tslib_1.__decorate([
    transactional_1.Transactional(),
    tslib_1.__metadata("design:type", Function),
    tslib_1.__metadata("design:paramtypes", [Object, Object]),
    tslib_1.__metadata("design:returntype", Promise)
], InviteUserService.prototype, "inviteUser", null);
tslib_1.__decorate([
    transactional_1.Transactional(),
    tslib_1.__metadata("design:type", Function),
    tslib_1.__metadata("design:paramtypes", [Object, Object]),
    tslib_1.__metadata("design:returntype", Promise)
], InviteUserService.prototype, "reInviteUser", null);
tslib_1.__decorate([
    transactional_1.Transactional(),
    tslib_1.__metadata("design:type", Function),
    tslib_1.__metadata("design:paramtypes", [Object, String, String, String]),
    tslib_1.__metadata("design:returntype", Promise)
], InviteUserService.prototype, "activateAccount", null);
InviteUserService = tslib_1.__decorate([
    common_1.Injectable(),
    tslib_1.__param(1, common_1.Inject(mail_sender_1.MAIL_SENDER)),
    tslib_1.__param(2, common_1.Inject(configuration_1.CONFIGURATION)),
    tslib_1.__param(3, common_1.Inject(index_1.USER_SERVICE)),
    tslib_1.__metadata("design:paramtypes", [auth_repository_1.CredentialRepository, Object, Object, Object, auth_repository_1.UserInviteRepository])
], InviteUserService);
exports.InviteUserService = InviteUserService;
//# sourceMappingURL=invite-user.service.js.map