@notadd/cli/lib/commands/generate/createDomain.js

notadd core none dependence

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CreateDomainService = void 0;
const tslib_1 = require("tslib");
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const lodash_1 = require("lodash");
const util_1 = require("./util");
const core_1 = require("@notadd/core");
let CreateDomainService = class CreateDomainService {
    constructor(util) {
        this.util = util;
    }
    createDomain(entities) {
        const dirName = entities[0].dirName;
        // 获取不同层的package.json
        const { domainDir, entitiesPakcageJson, basicPakcageJson } = this.util.getPackageJsons(entities);
        fs_extra_1.ensureDirSync(domainDir);
        //创建domain文件
        entities.forEach((it) => {
            const thisFileUrl = path_1.join(domainDir, it.fileName.replace('.entity.ts', '.service.ts'));
            // 如果在domain层已经存在就return
            if (fs_extra_1.pathExistsSync(thisFileUrl)) {
                console.log(`domain层${it.fileName.replace('.entity.ts', '.service.ts')}已存在，所以未生成`);
                return;
            }
            const domainContent = this._createDomainContent(it, entitiesPakcageJson, basicPakcageJson);
            fs_extra_1.writeFileSync(thisFileUrl, domainContent);
        });
        // 导入文件 导入文件名 导出文件
        const imports = this.util.importExportFileAndImportNames(entities, 'service');
        // 创建.module.ts
        const moduleContent = this._createModuleContent(entities, imports, basicPakcageJson);
        const basicModuleName = `${dirName}.module.ts`;
        const basicModuleUrl = path_1.join(domainDir, basicModuleName);
        if (fs_extra_1.pathExistsSync(basicModuleUrl)) {
            console.log(`domain层已存在${basicModuleName}文件，所以未生成`);
        }
        else {
            fs_extra_1.writeFileSync(basicModuleUrl, moduleContent);
        }
        //创建此模块的index.ts 和修改模块的导出
        this.util.createIndexTs(dirName, domainDir, imports.exportFile);
    }
    _createModuleContent(entities, imports, basicPakcageJson) {
        const dirName = entities[0].dirName;
        return `
import { Module } from '@notadd/core';
import { ${lodash_1.upperFirst(dirName)}BasicModule } from '${basicPakcageJson.name}';${imports.importFile}
@Module({
    imports: [
        ${lodash_1.upperFirst(dirName)}BasicModule,
    ],
    providers: [
        ${imports.importNames}
    ]
})
export class ${lodash_1.upperFirst(dirName)}DomainModule {}
    `;
    }
    _createDomainContent(it, entitiesPakcageJson, basicPakcageJson) {
        const basicName = it.entityName.replace(/Entity$/, 'Basic');
        const domainName = it.entityName.replace(/Entity$/, 'Service');
        const usedEntity = lodash_1.lowerFirst(it.entityName.replace(/Entity$/, ''));
        return `
import { TypeormError, TypeError } from '@ganker/error';
import { Limit } from '@notadd/graphql';
import { Injectable, Inject, Logger } from '@notadd/core';
import { DeepPartial, Repository } from '@notadd/typeorm';
import { ClassValidatorService } from '@notadd/class-validator';
import { ${it.entityName} } from '${entitiesPakcageJson.name}';
import { ${basicName} } from '${basicPakcageJson.name}';

@Injectable()
export class ${domainName} {
    constructor(
        @Inject(${it.entityName}) private ${usedEntity}: Repository<${it.entityName}>,
        private readonly ${lodash_1.lowerFirst(basicName)}: ${basicName},
        private readonly validator: ClassValidatorService,
        private logger: Logger,
    ) {}

    /**
     * 添加
     */
    async add(input: DeepPartial<${it.entityName}>): Promise<${it.entityName}> {
        const errMessage = await this.validator.validateOrMessage(input, ${it.entityName});
        if (errMessage) throw new TypeError('02', errMessage);
        try {
            const entity = this.${usedEntity}.create(input);
            const res = await this.${usedEntity}.save(entity);
            res.id = this.${usedEntity}.getId(res);
            return res;
        } catch (e) {
            this.logger.info(e.message);
            throw new TypeormError('01', e.message);
        }
    }
    /**
     * 删除
     */
    async deleteById(id: number): Promise<any> {
        if (!id || id <= 0) {
            throw new TypeError('02', 'id不能为空');
        }
        const item = await this.${usedEntity}.findOne({ id });
        if (!item) {
            throw new TypeError('03', '此记录未找到或已删除');
        }
        try {
            await this.${usedEntity}.delete({ id });
            return item;
        } catch (e) {
            this.logger.info(e.message);
            throw new TypeormError('01', e.message);
        }
    }
    /**
     * 修改
     */
    async updateById(id: number, entity: any): Promise<any> {
        if (!id || id <= 0) {
            throw new TypeError('03', 'id不能为空');
        }
        const item = await this.${usedEntity}.findOne({ id });
        if (!item) {
            throw new TypeError('04', '修改失败,未找到要修改的数据或已删除');
        }
        const errMessage = await this.validator.validateOrMessage(entity, ${it.entityName}, {
            skipMissingProperties: true,
        });
        if (errMessage) throw new TypeError('02', errMessage);
        try {
            await this.${usedEntity}.update({ id }, entity);
            return item;
        } catch (e) {
            this.logger.info(e.message);
            throw new TypeormError('01', e.message);
        }
    }
    /**
     * 列表
     */
    async list(where?: any, limit?: Limit, order?: any): Promise<any> {
        try {
            if (order) {
                order = Object.keys(order).reduce((newData, key) => {
                    let newKey = 'entity.' + key;
                    newData[newKey] = order[key];
                    return newData;
                }, {});
            } else {
                order = { 'entity.createDate': 'DESC' };
            }
            const [list, count] = await this.${lodash_1.lowerFirst(basicName)}.find${it.entityName.replace(/Entity$/, '')}List(where, limit, order);
            return { list, count };
        } catch (e) {
            this.logger.info(e.message);
            throw new TypeormError('01', e.message);
        }
    }
    /**
     * 详情
     */
    async detailById(id: number): Promise<${it.entityName}> {
        if (!id || id <= 0) {
            throw new TypeError('01', 'id不能为空');
        }
        const item = await this.${usedEntity}.findOne({ id });
        if (!item) {
            throw new TypeError('02', '查询失败,未找到要查询的数据或已删除');
        }
        return item;
    }

}`;
    }
};
CreateDomainService = tslib_1.__decorate([
    core_1.Injectable(),
    tslib_1.__metadata("design:paramtypes", [util_1.UtilService])
], CreateDomainService);
exports.CreateDomainService = CreateDomainService;