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

notadd core none dependence

import { join } from 'path';
import { writeFileSync, ensureDirSync, pathExistsSync } from 'fs-extra';
import { upperFirst, lowerFirst } from 'lodash';
import { ReadEntitiesResult } from './readEntities';
import { UtilService } from './util';
import { Injectable } from '@notadd/core';
@Injectable()
export class CreateDomainService {
	constructor(private util: UtilService) {}
	createDomain(entities: ReadEntitiesResult[]) {
		const dirName = entities[0].dirName;
		// 获取不同层的package.json
		const { domainDir, entitiesPakcageJson, basicPakcageJson } = this.util.getPackageJsons(entities);
		ensureDirSync(domainDir);
		//创建domain文件
		entities.forEach((it) => {
			const thisFileUrl = join(domainDir, it.fileName.replace('.entity.ts', '.service.ts'));
			// 如果在domain层已经存在就return
			if (pathExistsSync(thisFileUrl)) {
				console.log(`domain层${it.fileName.replace('.entity.ts', '.service.ts')}已存在，所以未生成`);
				return;
			}
			const domainContent = this._createDomainContent(it, entitiesPakcageJson, basicPakcageJson);
			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 = join(domainDir, basicModuleName);
		if (pathExistsSync(basicModuleUrl)) {
			console.log(`domain层已存在${basicModuleName}文件，所以未生成`);
		} else {
			writeFileSync(basicModuleUrl, moduleContent);
		}
		//创建此模块的index.ts 和修改模块的导出
		this.util.createIndexTs(dirName, domainDir, imports.exportFile);
	}

	private _createModuleContent(entities: ReadEntitiesResult[], imports: any, basicPakcageJson: any) {
        const dirName = entities[0].dirName;
        return `
import { Module } from '@notadd/core';
import { ${upperFirst(dirName)}BasicModule } from '${basicPakcageJson.name}';${imports.importFile}
@Module({
    imports: [
        ${upperFirst(dirName)}BasicModule,
    ],
    providers: [
        ${imports.importNames}
    ]
})
export class ${upperFirst(dirName)}DomainModule {}
    `;
	}

	private _createDomainContent(it: ReadEntitiesResult, entitiesPakcageJson: any, basicPakcageJson: any) {
		const basicName = it.entityName.replace(/Entity$/, 'Basic');
		const domainName = it.entityName.replace(/Entity$/, 'Service');
		const usedEntity = 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 ${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.${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;
    }

}`;
	}
}