@lomray/microservice-users/repositories/user.js

Users microservice based on NodeJS & inverted json.

'use strict';

var tslib = require('tslib');
var microserviceHelpers = require('@lomray/microservice-helpers');
var microserviceNodejsLib = require('@lomray/microservice-nodejs-lib');
var bcrypt = require('bcrypt');
var typeorm = require('typeorm');
var remote = require('../config/remote.js');
var exceptionCode = require('../constants/exception-code.js');
var profile = require('../entities/profile.js');
var user = require('../entities/user.js');

let User = class User extends typeorm.Repository {
    /**
     * Encrypt user password
     */
    encryptPassword(user) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            if (user.password) {
                const { passwordSaltRounds } = yield remote();
                user.password = bcrypt.hashSync(user.password, passwordSaltRounds);
            }
            return user;
        });
    }
    /**
     * Validate user password
     */
    isValidPassword(user, password) {
        if (!user.password) {
            return false;
        }
        return bcrypt.compareSync(password, user.password);
    }
    /**
     * Find user by provider identifier
     */
    findUserByIdentifier(provider, identifier) {
        return this.createQueryBuilder('u')
            .withDeleted()
            .leftJoin('u.identityProviders', 'ip')
            .leftJoinAndSelect('u.profile', 'profile')
            .where('ip.provider = :provider AND identifier = :identifier', {
            provider,
            identifier,
        })
            .getOne();
    }
    /**
     * Add profile entity to user
     */
    attachProfile(user, updateParams) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            const repository = this.manager.getRepository(profile);
            const profile$1 = (yield repository.findOne({ userId: user.id }));
            if (updateParams) {
                profile$1.params = Object.assign(Object.assign({}, profile$1.params), updateParams);
                yield repository.save(profile$1);
            }
            user.profile = profile$1;
            return user;
        });
    }
    /**
     * Verify if restore account time is exceeded
     */
    verifyDeleteAt(user) {
        var _a, _b;
        return tslib.__awaiter(this, void 0, void 0, function* () {
            const { removedAccountRestoreTime } = yield remote();
            /**
             * If account wasn't removed
             */
            if (typeof ((_a = user === null || user === void 0 ? void 0 : user.deletedAt) === null || _a === void 0 ? void 0 : _a.toString()) !== 'string') {
                return;
            }
            const restoreTimeAllowance = new Date(((_b = user.deletedAt) === null || _b === void 0 ? void 0 : _b.getTime()) + removedAccountRestoreTime * 60 * 60 * 1000);
            if (new Date() < restoreTimeAllowance) {
                return;
            }
            throw new microserviceNodejsLib.BaseException({
                code: exceptionCode.ACCOUNT_REMOVED,
                message: 'Account was removed.',
                status: 403,
            });
        });
    }
    /**
     * Clear  user tokens
     * @description Use cases:
     * 1. If token passed - clear rest user tokens
     * 2. If token not passed - clear all user tokens
     */
    clearUserTokens(userId, tokenId) {
        return tslib.__awaiter(this, void 0, void 0, function* () {
            const query = {
                where: Object.assign({ userId }, (tokenId ? { id: { '!=': tokenId } } : {})),
            };
            // Check if user have any else tokens
            const { error: countError, result: countResult } = yield microserviceHelpers.Api.get().authentication.token.count({
                query,
            });
            if (countError) {
                microserviceHelpers.Log.error(countError.message);
                throw new microserviceNodejsLib.BaseException({
                    status: 500,
                    message: 'Failed to clear rest user tokens.',
                    payload: {
                        message: countError.message,
                    },
                });
            }
            // If tokens do not exist
            if (!(countResult === null || countResult === void 0 ? void 0 : countResult.count)) {
                return;
            }
            const { error: tokenRemoveError } = yield microserviceHelpers.Api.get().authentication.token.remove({
                query,
                payload: {
                    authorization: {
                        filter: {
                            methodOptions: {
                                isAllowMultiple: true,
                            },
                        },
                    },
                },
            });
            if (!tokenRemoveError) {
                return;
            }
            microserviceHelpers.Log.error(tokenRemoveError.message);
            throw new microserviceNodejsLib.BaseException({
                status: 500,
                message: 'Failed to remove user tokens.',
                payload: {
                    message: tokenRemoveError.message,
                },
            });
        });
    }
};
User = tslib.__decorate([
    typeorm.EntityRepository(user)
], User);
var UserRepository = User;

module.exports = UserRepository;