wwjcloud-nest-v1/wwjcloud-nest-v1/tools/java-to-nestjs-migration/generators/enum-generator.js

const fs = require('fs');
const path = require('path');
const NamingUtils = require('../utils/naming-utils');

/**
 * 枚举生成器
 * 将Java枚举转换为NestJS枚举
 */
class EnumGenerator {
  constructor() {
    this.namingUtils = new NamingUtils();
  }

  /**
   * 生成枚举文件
   */
  generateEnum(javaEnum, outputDir) {
    const enumName = this.namingUtils.generateEnumName(javaEnum.className);
    const fileName = this.namingUtils.generateFileName(javaEnum.className, 'enum');
    const filePath = path.join(outputDir, fileName);
    
    const content = this.generateEnumContent(javaEnum, enumName);
    fs.writeFileSync(filePath, content);
    
    console.log(`✅ 生成枚举: ${filePath}`);
    return { fileName, content };
  }

  /**
   * 生成枚举内容
   */
  generateEnumContent(javaEnum, enumName) {
    const imports = this.generateImports(javaEnum);
    const decorators = this.generateDecorators(javaEnum);
    const values = this.generateEnumValues(javaEnum);
    
    return `${imports}

${decorators}
export enum ${enumName} {
${values}
}
`;
  }

  /**
   * 生成导入语句
   */
  generateImports(javaEnum) {
    const imports = [
      "import { ApiProperty } from '@nestjs/swagger';"
    ];

    return imports.join('\n');
  }

  /**
   * 生成装饰器
   */
  generateDecorators(javaEnum) {
    const decorators = [];
    
    // 根据枚举类型添加装饰器
    if (javaEnum.enumType === 'status') {
      decorators.push('export enum StatusEnum {');
    } else if (javaEnum.enumType === 'type') {
      decorators.push('export enum TypeEnum {');
    } else if (javaEnum.enumType === 'action') {
      decorators.push('export enum ActionEnum {');
    } else {
      decorators.push('export enum ' + this.namingUtils.toPascalCase(javaEnum.className) + 'Enum {');
    }
    
    return decorators.join('\n');
  }

  /**
   * 生成枚举值
   */
  generateEnumValues(javaEnum) {
    if (!javaEnum.values || javaEnum.values.length === 0) {
      return '  // 无枚举值';
    }

    return javaEnum.values.map(value => {
      return this.generateEnumValue(value);
    }).join(',\n');
  }

  /**
   * 生成单个枚举值
   */
  generateEnumValue(value) {
    const enumKey = this.namingUtils.toPascalCase(value.key);
    const enumValue = value.value;
    const description = value.description || value.key;
    
    return `  @ApiProperty({ description: '${description}' })
  ${enumKey} = '${enumValue}'`;
  }

  /**
   * 生成状态枚举
   */
  generateStatusEnum(javaEnum, outputDir) {
    const enumName = 'StatusEnum';
    const fileName = 'status.enum.ts';
    const filePath = path.join(outputDir, fileName);
    
    const content = this.generateStatusEnumContent(enumName);
    fs.writeFileSync(filePath, content);
    
    console.log(`✅ 生成状态枚举: ${filePath}`);
    return { fileName, content };
  }

  /**
   * 生成状态枚举内容
   */
  generateStatusEnumContent(enumName) {
    const imports = [
      "import { ApiProperty } from '@nestjs/swagger';"
    ].join('\n');
    
    const decorators = `export enum ${enumName} {`;
    
    const values = [
      "  @ApiProperty({ description: '启用' })",
      "  ENABLED = 'enabled',",
      "",
      "  @ApiProperty({ description: '禁用' })",
      "  DISABLED = 'disabled',",
      "",
      "  @ApiProperty({ description: '删除' })",
      "  DELETED = 'deleted'"
    ].join('\n');
    
    return `${imports}

${decorators}
${values}
}
`;
  }

  /**
   * 生成类型枚举
   */
  generateTypeEnum(javaEnum, outputDir) {
    const enumName = 'TypeEnum';
    const fileName = 'type.enum.ts';
    const filePath = path.join(outputDir, fileName);
    
    const content = this.generateTypeEnumContent(enumName);
    fs.writeFileSync(filePath, content);
    
    console.log(`✅ 生成类型枚举: ${filePath}`);
    return { fileName, content };
  }

  /**
   * 生成类型枚举内容
   */
  generateTypeEnumContent(enumName) {
    const imports = [
      "import { ApiProperty } from '@nestjs/swagger';"
    ].join('\n');
    
    const decorators = `export enum ${enumName} {`;
    
    const values = [
      "  @ApiProperty({ description: '系统类型' })",
      "  SYSTEM = 'system',",
      "",
      "  @ApiProperty({ description: '用户类型' })",
      "  USER = 'user',",
      "",
      "  @ApiProperty({ description: '管理员类型' })",
      "  ADMIN = 'admin'"
    ].join('\n');
    
    return `${imports}

${decorators}
${values}
}
`;
  }

  /**
   * 生成动作枚举
   */
  generateActionEnum(javaEnum, outputDir) {
    const enumName = 'ActionEnum';
    const fileName = 'action.enum.ts';
    const filePath = path.join(outputDir, fileName);
    
    const content = this.generateActionEnumContent(enumName);
    fs.writeFileSync(filePath, content);
    
    console.log(`✅ 生成动作枚举: ${filePath}`);
    return { fileName, content };
  }

  /**
   * 生成动作枚举内容
   */
  generateActionEnumContent(enumName) {
    const imports = [
      "import { ApiProperty } from '@nestjs/swagger';"
    ].join('\n');
    
    const decorators = `export enum ${enumName} {`;
    
    const values = [
      "  @ApiProperty({ description: '创建' })",
      "  CREATE = 'create',",
      "",
      "  @ApiProperty({ description: '更新' })",
      "  UPDATE = 'update',",
      "",
      "  @ApiProperty({ description: '删除' })",
      "  DELETE = 'delete',",
      "",
      "  @ApiProperty({ description: '查看' })",
      "  VIEW = 'view'"
    ].join('\n');
    
    return `${imports}

${decorators}
${values}
}
`;
  }

  /**
   * 验证枚举一致性
   */
  validateEnumConsistency(javaEnum, nestJSEnum) {
    const issues = [];
    
    // 验证枚举值数量
    if (javaEnum.values.length !== nestJSEnum.values.length) {
      issues.push('枚举值数量不一致');
    }
    
    // 验证每个枚举值
    javaEnum.values.forEach((javaValue, index) => {
      const nestJSValue = nestJSEnum.values[index];
      if (nestJSValue && javaValue.key !== nestJSValue.key) {
        issues.push(`枚举值不一致: ${javaValue.key} vs ${nestJSValue.key}`);
      }
    });
    
    return issues;
  }
}

module.exports = EnumGenerator;