create-dp-koa 1.0.1 → 1.0.2

package/template/src/service/ytGoods.service.ts

@@ -1,42 +0,0 @@
-import { BaseService } from "@src/service/base.service";
-import { CommonServiceResult, CommonServiceResultCode } from "@src/framework/types/ServiceResult";
-import { YtGoodsUnlockerEntity } from "@src/entity/goodsUnlocker.entity";
-import { GoodsImagesUnlockKeyEntity } from "@src/entity/goodsImagesUnlockKey.entity";
-
-export class YtGoodsService extends BaseService {
-    
-    
-    async unlockGoodsImage(goodsId: number, userId: number, key: string): Promise<CommonServiceResult<boolean>> {
-        // 验证解锁key
-        const keyRepo = this.getDataRepository(GoodsImagesUnlockKeyEntity);
-        const unlockKey = await keyRepo.findOneBy({ key });
-        
-        if (!unlockKey || unlockKey.isUse) {
-            return new CommonServiceResult(CommonServiceResultCode.FAIL, false, "无效的解锁key");
-        }
-        
-        // 标记key为已使用
-        unlockKey.isUse = true;
-        await keyRepo.save(unlockKey);
-        
-        // 创建解锁记录
-        const unlockRepo = this.getDataRepository(YtGoodsUnlockerEntity);
-        await unlockRepo.save({
-            goodsId,
-            ytUserId: userId
-        });
-        
-        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, true);
-    }
-
-    /**
-     * 根据ID获取商品（兼容旧接口）
-     */
-    async getById(entityClass: any, id: number): Promise<any> {
-        try {
-            return await this.getDataRepository(entityClass).findOne({ where: { id } });
-        } catch (error) {
-            return null;
-        }
-    }
-}

package/template/src/service/ytShop.service.ts

@@ -1,90 +0,0 @@
-import { YtGoodsEntity, YtGoodsStatusEnum } from "@src/entity/ytGoods.entity";
-import { BaseService } from "@src/service/base.service";
-import { CommonServiceResult, CommonServiceResultCode } from "@src/framework/types/ServiceResult";
-import { YtUserEntity } from "@src/entity/ytUser.entity";
-import { ShopAndUserEntity } from "@src/entity/shopUser.entity";
-
-export class YtShopService extends BaseService {
-
-
-    /**
-     * 获取店铺的商品列表
-     * @param shopId 
-     * @param page 
-     * @param pageSize 
-     * @returns 
-     */
-    async getGoodsListByShopId(
-        shopId: number,
-        page: number,
-        pageSize: number
-    ): Promise<CommonServiceResult<[YtGoodsEntity[], number]>> {
-        const ds = this.getDataRepository(YtGoodsEntity);
-        try {
-            const result = await ds.findAndCount({
-                where: { shopId, status: YtGoodsStatusEnum.NORMAL },
-                skip: (page - 1) * pageSize,
-                take: pageSize,
-                order: { id: "DESC" }
-            });
-            return new CommonServiceResult(CommonServiceResultCode.SUCCESS, result);
-        } catch (error) {
-            return new CommonServiceResult(CommonServiceResultCode.ERROR, [[], 0], "查询商品列表失败");
-        }
-    }
-
-
-    /**
-     * 读取店铺的用户基本信息
-     * @param shopId 
-     */
-    async getShopUserInfo(shopId: number): Promise<CommonServiceResult<YtUserEntity | null>> {
-
-        const relation = await this.getDataRepository(ShopAndUserEntity).findOne({
-            where: {
-                shopId,
-            }
-        });
-
-        if (!relation) {
-            return new CommonServiceResult(CommonServiceResultCode.FAIL, null, "店铺未绑定用户")
-        }
-
-
-
-        const user = await this.getDataRepository(YtUserEntity).findOne({
-            where: {
-                id: relation.userId,
-            }
-        })
-        if (!user) {
-            return new CommonServiceResult(CommonServiceResultCode.FAIL, null, "用户不存在");
-        }
-        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, user,);
-    }
-
-
-    /**
-     * 检测用户是否有店铺 如果有，则返回shop id
-     * @param userId 
-     */
-    async checkHasShop(userId: number): Promise<CommonServiceResult<number | null>> {
-        const result = await this.getDataRepository(ShopAndUserEntity).findOne({
-            where: {
-                userId,
-            }
-        })
-        return new CommonServiceResult(CommonServiceResultCode.SUCCESS, result?.shopId || null);
-    }
-
-    /**
-     * 根据ID获取店铺（兼容旧接口）
-     */
-    async getById(entityClass: any, id: number): Promise<any> {
-        try {
-            return await this.getDataRepository(entityClass).findOne({ where: { id } });
-        } catch (error) {
-            return null;
-        }
-    }
-}

package/template/src/service/ytUser.service.ts

@@ -1,451 +0,0 @@
-import { Injectable } from "dp-ioc2";
-import { transactionManager } from "@src/framework/utils/TransactionManager";
-import { UserRepository, IUserRepository } from "@src/repository/UserRepository";
-import { YtUserEntity, YtUserTypeEnum, YtUserStatusEnum } from "@src/entity/ytUser.entity";
-import { CreateUserDto, UpdateUserDto, QueryUserDto, LoginUserDto, ChangePasswordDto } from "@src/dto/user.dto";
-import { DtoValidator, ValidationResult } from "@src/framework/utils/DtoValidator";
-import { CommonServiceResultCode, CommonServiceResult } from "@src/framework/types/ServiceResult";
-import { logger } from "@src/framework/utils/logger";
-import { BaseService } from "@src/service/base.service";
-import * as bcrypt from 'bcryptjs';
-import { ServiceValidate } from "@src/libs/serviceValidate";
-import { isDebug } from "@src/framework/utils/function";
-
-/**
- * 企业级用户服务
- * 使用Repository模式和事务管理
- */
-@Injectable()
-export class YtUserService extends BaseService {
-    private repositoryCache = new Map<string, any>();
-
-    /**
-     * 获取用户Repository（懒加载）
-     * 使用基类的通用方法
-     */
-    private get userRepository(): IUserRepository {
-        return this.createLazyRepository(
-            YtUserEntity,
-            UserRepository,
-            this.repositoryCache
-        );
-    }
-
-
-    // @Interceptor(ServiceValidate(TestValidateServiceDto))
-    // async validateTest (param:TestValidateServiceDto){
-    // }
-
-    /**
-     * 创建用户
-     */
-    async createUser(createUserDto: CreateUserDto): Promise<CommonServiceResult<YtUserEntity>> {
-        try {
-            // 验证DTO
-            const validation = await DtoValidator.validateAndTransform(CreateUserDto, createUserDto);
-            if (!validation.isValid) {
-                return CommonServiceResult.validationError(validation.errors.join(', '));
-            }
-
-            // 验证密码强度
-            if (!this.validatePasswordStrength(createUserDto.password)) {
-                return CommonServiceResult.validationError(
-                    "密码强度不足。密码必须至少8位，包含数字、字母和特殊字符"
-                );
-            }
-
-            // 检查邮箱是否已存在
-            const existingUserByEmail = await this.userRepository.findByEmail(createUserDto.email);
-            if (existingUserByEmail) {
-                return CommonServiceResult.conflict("邮箱已被使用");
-            }
-
-            // 检查手机号是否已存在
-            const existingUserByTel = await this.userRepository.findByTelNumber(createUserDto.telnumber);
-            if (existingUserByTel) {
-                return CommonServiceResult.conflict("手机号已被使用");
-            }
-
-            // 使用事务创建用户
-            const user = await transactionManager.executeInTransaction(async (manager) => {
-                // 加密密码
-                const hashedPassword = await bcrypt.hash(createUserDto.password, 10);
-                
-                // 创建用户实体
-                const userData = {
-                    ...validation.data,
-                    password: hashedPassword,
-                    userType: createUserDto.userType || YtUserTypeEnum.CUSTOMER,
-                    status: createUserDto.status || YtUserStatusEnum.NORMAL,
-                };
-
-                return await this.userRepository.save(userData);
-            });
-
-            logger.info(`用户创建成功: ${this.maskEmail(user.email)}`);
-            return CommonServiceResult.success(user, "用户创建成功");
-
-        } catch (error) {
-            logger.error("创建用户失败:", error as Error);
-            // 生产环境不返回详细错误，避免信息泄露
-            const errorMessage = !isDebug()
-                ? "创建用户时发生错误"
-                : error instanceof Error ? error.message : "创建用户时发生错误";
-            return CommonServiceResult.error(errorMessage);
-        }
-    }
-
-    /**
-     * 更新用户
-     */
-    async updateUser(id: number, updateUserDto: UpdateUserDto): Promise<CommonServiceResult<YtUserEntity | null>> {
-        try {
-            // 验证DTO
-            const validation = await DtoValidator.validatePartial(UpdateUserDto, updateUserDto);
-            if (!validation.isValid) {
-                return CommonServiceResult.validationError(validation.errors.join(', '));
-            }
-
-            // 检查用户是否存在
-            const existingUser = await this.userRepository.findById(id);
-            if (!existingUser) {
-                return CommonServiceResult.notFound("用户不存在");
-            }
-
-            // 使用事务更新用户
-            const updatedUser = await transactionManager.executeInTransaction(async (manager) => {
-                // 检查邮箱是否被其他用户使用
-                if (updateUserDto.email && updateUserDto.email !== existingUser.email) {
-                    const userWithEmail = await this.userRepository.findByEmail(updateUserDto.email);
-                    if (userWithEmail && userWithEmail.id !== id) {
-                        throw new Error("邮箱已被其他用户使用");
-                    }
-                }
-
-                // 检查手机号是否被其他用户使用
-                if (updateUserDto.telnumber && updateUserDto.telnumber !== existingUser.telnumber) {
-                    const userWithTel = await this.userRepository.findByTelNumber(updateUserDto.telnumber);
-                    if (userWithTel && userWithTel.id !== id) {
-                        throw new Error("手机号已被其他用户使用");
-                    }
-                }
-
-                await this.userRepository.update(id, validation.data);
-                return await this.userRepository.findById(id);
-            });
-
-            logger.info(`用户更新成功: ${updatedUser?.email ? this.maskEmail(updatedUser.email) : ''}`);
-            return CommonServiceResult.success(updatedUser, "用户更新成功");
-
-        } catch (error) {
-            logger.error("更新用户失败:", error as Error);
-            // 生产环境不返回详细错误
-            const errorMessage = !isDebug()
-                ? "更新用户时发生错误"
-                : error instanceof Error ? error.message : "更新用户时发生错误";
-            return CommonServiceResult.error(errorMessage);
-        }
-    }
-
-    /**
-     * 根据ID获取用户
-     */
-    async getUserById(id: number): Promise<CommonServiceResult<YtUserEntity | null>> {
-        try {
-            const user = await this.userRepository.findById(id);
-            if (!user) {
-                return CommonServiceResult.notFound("用户不存在");
-            }
-
-            return CommonServiceResult.success(user);
-
-        } catch (error) {
-            logger.error("获取用户失败:", error as Error);
-            return CommonServiceResult.error("获取用户时发生错误");
-        }
-    }
-
-    /**
-     * 用户登录
-     */
-    async login(loginDto: LoginUserDto): Promise<CommonServiceResult<YtUserEntity | null>> {
-        try {
-            // 验证DTO
-            const validation = await DtoValidator.validateAndTransform(LoginUserDto, loginDto);
-            if (!validation.isValid) {
-                return CommonServiceResult.validationError(validation.errors.join(', '));
-            }
-
-            // 查找用户（通过邮箱或手机号）
-            let user = await this.userRepository.findByEmail(loginDto.credential);
-            if (!user) {
-                user = await this.userRepository.findByTelNumber(loginDto.credential);
-            }
-
-            if (!user) {
-                return CommonServiceResult.notFound("用户不存在");
-            }
-
-            // 检查用户状态
-            if (user.status === YtUserStatusEnum.FORBIDDEN) {
-                return CommonServiceResult.forbidden("用户已被禁用");
-            }
-
-            // 验证密码
-            const isPasswordValid = await bcrypt.compare(loginDto.password, user.password);
-            if (!isPasswordValid) {
-                return CommonServiceResult.unauthorized("密码错误");
-            }
-
-            // 更新最后登录时间
-            await this.userRepository.updateLastLoginTime(user.id);
-
-            logger.info(`用户登录成功: ${this.maskEmail(user.email)}`);
-            return CommonServiceResult.success(user, "登录成功");
-
-        } catch (error) {
-            logger.error("用户登录失败:", error as Error);
-            return CommonServiceResult.error("登录时发生错误");
-        }
-    }
-
-    /**
-     * 修改密码
-     */
-    async changePassword(id: number, changePasswordDto: ChangePasswordDto): Promise<CommonServiceResult<boolean>> {
-        try {
-            // 验证DTO
-            const validation = await DtoValidator.validateAndTransform(ChangePasswordDto, changePasswordDto);
-            if (!validation.isValid) {
-                return CommonServiceResult.validationError(validation.errors.join(', '), false);
-            }
-
-            // 检查新密码和确认密码是否一致
-            if (changePasswordDto.newPassword !== changePasswordDto.confirmPassword) {
-                return CommonServiceResult.validationError("新密码和确认密码不一致", false);
-            }
-
-            // 使用事务修改密码
-            await transactionManager.executeInTransaction(async (manager) => {
-                // 获取用户
-                const user = await this.userRepository.findById(id);
-                if (!user) {
-                    throw new Error("用户不存在");
-                }
-
-                // 验证当前密码
-                const isCurrentPasswordValid = await bcrypt.compare(
-                    changePasswordDto.currentPassword,
-                    user.password
-                );
-                if (!isCurrentPasswordValid) {
-                    throw new Error("当前密码错误");
-                }
-
-                // 加密新密码
-                const hashedNewPassword = await bcrypt.hash(changePasswordDto.newPassword, 10);
-                
-                // 更新密码
-                await this.userRepository.updatePassword(id, hashedNewPassword);
-            });
-
-            logger.info(`用户密码修改成功: ${id}`);
-            return CommonServiceResult.success(true, "密码修改成功");
-
-        } catch (error) {
-            logger.error("修改密码失败:", error as Error);
-            return CommonServiceResult.error(error instanceof Error ? error.message : "修改密码时发生错误", false);
-        }
-    }
-
-    /**
-     * 查询用户列表
-     */
-    async getUsers(queryDto: QueryUserDto): Promise<CommonServiceResult<[YtUserEntity[], number]>> {
-        try {
-            // 验证DTO
-            const validation = await DtoValidator.validatePartial(QueryUserDto, queryDto);
-            if (!validation.isValid) {
-                return new CommonServiceResult(
-                    CommonServiceResultCode.VALIDATION_ERROR,
-                    [[], 0],
-                    validation.errors.join(', ')
-                );
-            }
-
-            const { page = 1, pageSize = 10, sortBy = 'id', sortOrder = 'DESC', ...filters } = validation.data;
-
-            // 构建查询条件
-            const whereConditions: any = {};
-            
-            if (filters.userType) {
-                whereConditions.userType = filters.userType;
-            }
-            
-            if (filters.status) {
-                whereConditions.status = filters.status;
-            }
-
-            // 执行查询
-            const [users, total] = await this.userRepository.findAndCount({
-                where: whereConditions,
-                skip: (page - 1) * pageSize,
-                take: pageSize,
-                order: { [sortBy]: sortOrder }
-            });
-
-            return new CommonServiceResult(CommonServiceResultCode.SUCCESS, [users, total]);
-
-        } catch (error) {
-            logger.error("查询用户列表失败:", error as Error);
-            return new CommonServiceResult(
-                CommonServiceResultCode.ERROR,
-                [[], 0],
-                "查询用户列表时发生错误"
-            );
-        }
-    }
-
-    /**
-     * 删除用户
-     */
-    async deleteUser(id: number): Promise<CommonServiceResult<boolean>> {
-        try {
-            // 检查用户是否存在
-            const user = await this.userRepository.findById(id);
-            if (!user) {
-                return new CommonServiceResult(
-                    CommonServiceResultCode.NOT_FOUND,
-                    false,
-                    "用户不存在"
-                );
-            }
-
-            // 使用事务删除用户
-            await transactionManager.executeInTransaction(async (manager) => {
-                await this.userRepository.delete(id);
-            });
-
-            logger.info(`用户删除成功: ${id}`);
-            return new CommonServiceResult(CommonServiceResultCode.SUCCESS, true, "用户删除成功");
-
-        } catch (error) {
-            logger.error("删除用户失败:", error as Error);
-            return new CommonServiceResult(
-                CommonServiceResultCode.ERROR,
-                false,
-                "删除用户时发生错误"
-            );
-        }
-    }
-
-    /**
-     * 激活/禁用用户
-     */
-    async toggleUserStatus(id: number, activate: boolean): Promise<CommonServiceResult<boolean>> {
-        try {
-            // 检查用户是否存在
-            const user = await this.userRepository.findById(id);
-            if (!user) {
-                return new CommonServiceResult(
-                    CommonServiceResultCode.NOT_FOUND,
-                    false,
-                    "用户不存在"
-                );
-            }
-
-            // 更新用户状态
-            if (activate) {
-                await this.userRepository.activateUser(id);
-            } else {
-                await this.userRepository.deactivateUser(id);
-            }
-
-            const action = activate ? "激活" : "禁用";
-            logger.info(`用户${action}成功: ${id}`);
-            return new CommonServiceResult(CommonServiceResultCode.SUCCESS, true, `用户${action}成功`);
-
-        } catch (error) {
-            logger.error("切换用户状态失败:", error as Error);
-            return new CommonServiceResult(
-                CommonServiceResultCode.ERROR,
-                false,
-                "切换用户状态时发生错误"
-            );
-        }
-    }
-
-    /**
-     * 根据邮箱查找用户（兼容旧接口）
-     */
-    async findByEmail(email: string): Promise<YtUserEntity | null> {
-        try {
-            return await this.userRepository.findByEmail(email);
-        } catch (error) {
-            logger.error("根据邮箱查找用户失败:", error as Error);
-            return null;
-        }
-    }
-
-    /**
-     * 添加用户（兼容旧接口）
-     * 注意：此方法用于兼容旧代码，新代码应使用 createUser
-     */
-    async addUser(user: YtUserEntity): Promise<YtUserEntity> {
-        try {
-            return await this.userRepository.save(user);
-        } catch (error) {
-            logger.error("添加用户失败:", error as Error);
-            throw error;
-        }
-    }
-
-    /**
-     * 根据ID获取用户（兼容旧接口）
-     * 注意：此方法用于兼容旧代码，新代码应使用 getUserById
-     */
-    async getUserByIdLegacy(entityClass: any, id: number): Promise<YtUserEntity | null> {
-        try {
-            return await this.userRepository.findById(id);
-        } catch (error) {
-            logger.error("根据ID获取用户失败:", error as Error);
-            return null;
-        }
-    }
-
-    /**
-     * 邮箱脱敏处理
-     * 用于日志记录，保护用户隐私
-     */
-    private maskEmail(email: string): string {
-        if (!email || !email.includes('@')) return email;
-        const [name, domain] = email.split('@');
-        const maskedName = name.length > 2 
-            ? name.substring(0, 2) + '***' 
-            : '***';
-        return `${maskedName}@${domain}`;
-    }
-
-    /**
-     * 验证密码强度
-     * 要求：至少8位，包含数字、字母和特殊字符
-     */
-    private validatePasswordStrength(password: string): boolean {
-        if (password.length < 8) return false;
-        
-        const hasNumber = /\d/.test(password);
-        const hasLetter = /[a-zA-Z]/.test(password);
-        const hasSpecial = /[!@#$%^&*(),.?":{}|<>]/.test(password);
-        
-        return hasNumber && hasLetter && hasSpecial;
-    }
-
-    /**
-     * 清理资源
-     * 在应用关闭时调用
-     */
-    cleanup(): void {
-        this.repositoryCache.clear();
-        logger.info('YtUserService 资源已清理');
-    }
-}

package/template/src/test/swaggerParameterTest.ts

@@ -1,90 +0,0 @@
-/**
- * 测试Swagger处理器的参数推断功能
- */
-
-import { swaggerProcessor } from '@src/annotations/processors/SwaggerProcessor';
-import { SwaggerExampleController } from '@src/controllers/example/SwaggerExampleController';
-import { logger } from '@src/framework/utils/logger';
-
-/**
- * 测试参数推断功能
- */
-export function testSwaggerParameterInference() {
-    try {
-        logger.info('=== 测试Swagger处理器参数推断功能 ===');
-        
-        // 测试getUserById方法的参数推断
-        const methodName = 'getUserById';
-        const methodMetadata = swaggerProcessor.processMethod(SwaggerExampleController, methodName);
-        
-        logger.info(`方法 ${methodName} 的参数信息:`);
-        logger.info(`  - 参数数量: ${methodMetadata.parameters.length}`);
-        
-        methodMetadata.parameters.forEach((param, index) => {
-            logger.info(`  - 参数 ${index + 1}:`);
-            logger.info(`    * 名称: ${param.name}`);
-            logger.info(`    * 位置: ${param.in}`);
-            logger.info(`    * 描述: ${param.description}`);
-            logger.info(`    * 必需: ${param.required}`);
-            logger.info(`    * 类型: ${JSON.stringify(param.schema)}`);
-        });
-        
-        // 测试updateUser方法的参数推断
-        const updateMethodName = 'updateUser';
-        const updateMethodMetadata = swaggerProcessor.processMethod(SwaggerExampleController, updateMethodName);
-        
-        logger.info(`\n方法 ${updateMethodName} 的参数信息:`);
-        logger.info(`  - 参数数量: ${updateMethodMetadata.parameters.length}`);
-        
-        updateMethodMetadata.parameters.forEach((param, index) => {
-            logger.info(`  - 参数 ${index + 1}:`);
-            logger.info(`    * 名称: ${param.name}`);
-            logger.info(`    * 位置: ${param.in}`);
-            logger.info(`    * 描述: ${param.description}`);
-            logger.info(`    * 必需: ${param.required}`);
-            logger.info(`    * 类型: ${JSON.stringify(param.schema)}`);
-        });
-        
-        // 测试OpenAPI规范生成
-        logger.info('\n=== 测试OpenAPI规范生成 ===');
-        const openAPISpec = swaggerProcessor.generateOpenAPISpec([SwaggerExampleController]);
-        
-        // 检查特定路径的参数
-        const userPath = '/swagger/c/user/{id}';
-        if (openAPISpec.paths[userPath]) {
-            const pathInfo = openAPISpec.paths[userPath];
-            
-            if (pathInfo.get) {
-                logger.info(`GET ${userPath} 参数:`);
-                if (pathInfo.get.parameters) {
-                    pathInfo.get.parameters.forEach((param: any, index: number) => {
-                        logger.info(`  - 参数 ${index + 1}: ${param.name} (${param.in})`);
-                    });
-                } else {
-                    logger.warn(`GET ${userPath} 没有参数定义`);
-                }
-            }
-            
-            if (pathInfo.put) {
-                logger.info(`PUT ${userPath} 参数:`);
-                if (pathInfo.put.parameters) {
-                    pathInfo.put.parameters.forEach((param: any, index: number) => {
-                        logger.info(`  - 参数 ${index + 1}: ${param.name} (${param.in})`);
-                    });
-                } else {
-                    logger.warn(`PUT ${userPath} 没有参数定义`);
-                }
-            }
-        }
-        
-        logger.info('Swagger处理器参数推断功能测试完成！');
-        
-    } catch (error) {
-        logger.error('测试Swagger处理器参数推断功能失败:', error as Error);
-    }
-}
-
-// 如果直接运行此文件，执行测试
-if (require.main === module) {
-    testSwaggerParameterInference();
-}