@rytass/cms-base-nestjs-module/services/signature.service.js

Rytass Content Management System NestJS Base Module

import { Injectable, Inject } from '@nestjs/common';
import { SIGNATURE_LEVELS, RESOLVED_SIGNATURE_LEVEL_REPO } from '../typings/cms-base-providers.js';
import { BaseSignatureLevelEntity } from '../models/base-signature-level.entity.js';
import { Repository, DataSource } from 'typeorm';
import { InjectDataSource } from '@nestjs/typeorm';
import { ArticleSignatureRepo } from '../models/article-signature.entity.js';

function _ts_decorate(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;
}
function _ts_metadata(k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
}
function _ts_param(paramIndex, decorator) {
    return function(target, key) {
        decorator(target, key, paramIndex);
    };
}
class SignatureService {
    signatureLevels;
    signatureLevelRepo;
    dataSource;
    articleSignatureRepo;
    constructor(signatureLevels, signatureLevelRepo, dataSource, articleSignatureRepo){
        this.signatureLevels = signatureLevels;
        this.signatureLevelRepo = signatureLevelRepo;
        this.dataSource = dataSource;
        this.articleSignatureRepo = articleSignatureRepo;
    }
    get signatureEnabled() {
        return this.signatureLevels.length > 0;
    }
    signatureLevelsCache = [];
    get finalSignatureLevel() {
        return this.signatureLevelsCache[this.signatureLevelsCache.length - 1] ?? null;
    }
    async onApplicationBootstrap() {
        if (this.signatureEnabled) {
            const signatureLevels = await this.signatureLevelRepo.find();
            const existedMap = new Map(signatureLevels.map((level)=>[
                    level.name,
                    level
                ]));
            const usedSet = new Set();
            const targetLevelNames = new Set(this.signatureLevels.map((level)=>level instanceof BaseSignatureLevelEntity ? level.name : level));
            const runner = this.dataSource.createQueryRunner();
            await runner.connect();
            await runner.startTransaction();
            try {
                await signatureLevels.filter((level)=>!targetLevelNames.has(level.name)).map((level)=>async ()=>{
                        await runner.manager.delete(this.articleSignatureRepo.metadata.tableName, {
                            signatureLevelId: level.id
                        });
                        await runner.manager.softDelete(this.signatureLevelRepo.metadata.tableName, {
                            id: level.id
                        });
                    }).reduce((prev, next)=>prev.then(next), Promise.resolve());
                this.signatureLevelsCache = await this.signatureLevels.map((level, index)=>async (levels)=>{
                        if (level instanceof BaseSignatureLevelEntity) {
                            level.sequence = index;
                            level.required = true;
                            await runner.manager.save(level);
                            usedSet.add(level);
                            return [
                                ...levels,
                                level
                            ];
                        }
                        if (existedMap.has(level)) {
                            const existedLevel = existedMap.get(level);
                            existedLevel.sequence = index;
                            existedLevel.required = true;
                            await runner.manager.save(existedLevel);
                            usedSet.add(existedLevel);
                            return [
                                ...levels,
                                existedLevel
                            ];
                        }
                        const newLevel = this.signatureLevelRepo.create({
                            name: level,
                            required: true,
                            sequence: index
                        });
                        await runner.manager.save(newLevel);
                        usedSet.add(newLevel);
                        return levels;
                    }).reduce((prev, next)=>prev.then(next), Promise.resolve([]));
                await runner.commitTransaction();
            } catch (ex) {
                await runner.rollbackTransaction();
                throw ex;
            } finally{
                await runner.release();
            }
        }
    }
}
SignatureService = _ts_decorate([
    Injectable(),
    _ts_param(0, Inject(SIGNATURE_LEVELS)),
    _ts_param(1, Inject(RESOLVED_SIGNATURE_LEVEL_REPO)),
    _ts_param(2, InjectDataSource()),
    _ts_param(3, Inject(ArticleSignatureRepo)),
    _ts_metadata("design:type", Function),
    _ts_metadata("design:paramtypes", [
        Array,
        typeof Repository === "undefined" ? Object : Repository,
        typeof DataSource === "undefined" ? Object : DataSource,
        typeof Repository === "undefined" ? Object : Repository
    ])
], SignatureService);

export { SignatureService };