658 lines
19 KiB
Dart
658 lines
19 KiB
Dart
import 'dart:io';
|
||
|
||
import 'package:path/path.dart' as path;
|
||
import 'package:swagger_generator_flutter/commands/generate_command.dart'
|
||
show GenerateOptions;
|
||
import 'package:swagger_generator_flutter/commands/services/service_typedefs.dart';
|
||
import 'package:swagger_generator_flutter/core/config.dart';
|
||
import 'package:swagger_generator_flutter/core/config_repository.dart';
|
||
import 'package:swagger_generator_flutter/core/models.dart';
|
||
import 'package:swagger_generator_flutter/generators/model_code_generator.dart';
|
||
import 'package:swagger_generator_flutter/generators/retrofit_api_generator.dart';
|
||
import 'package:swagger_generator_flutter/utils/file_utils.dart';
|
||
import 'package:swagger_generator_flutter/utils/logger.dart';
|
||
|
||
class GenerationOutputService {
|
||
const GenerationOutputService();
|
||
static ConfigRepository? _cachedConfig;
|
||
ConfigRepository get _config => _cachedConfig ??= ConfigRepository.loadSync();
|
||
|
||
Future<int> generateOutputs({
|
||
required SwaggerDocument document,
|
||
required GenerateOptions options,
|
||
required String baseDir,
|
||
required String apiDir,
|
||
required String modelsDir,
|
||
required LogCallback progress,
|
||
required LogCallback success,
|
||
}) async {
|
||
await FileUtils.ensureDirectoryExists(baseDir);
|
||
await FileUtils.ensureDirectoryExists(apiDir);
|
||
await FileUtils.ensureDirectoryExists(modelsDir);
|
||
|
||
var generatedFiles = 0;
|
||
|
||
if (options.generateModels) {
|
||
generatedFiles += await _generateModels(
|
||
document,
|
||
modelsDir,
|
||
progress,
|
||
success,
|
||
);
|
||
}
|
||
|
||
if (options.generateApi) {
|
||
generatedFiles += await _generateApis(
|
||
document,
|
||
apiDir,
|
||
modelsDir,
|
||
progress,
|
||
success,
|
||
);
|
||
}
|
||
|
||
if (options.generateModels || options.generateApi) {
|
||
await _regenerateModelsIndex(modelsDir, success);
|
||
}
|
||
|
||
await _generateSummary(document, baseDir);
|
||
return generatedFiles;
|
||
}
|
||
|
||
Future<int> _generateModels(
|
||
SwaggerDocument document,
|
||
String modelsDir,
|
||
LogCallback progress,
|
||
LogCallback success,
|
||
) async {
|
||
progress('正在生成数据模型...');
|
||
final generator = ModelCodeGenerator(document);
|
||
final modelFiles = generator.generateSeparateModelFiles();
|
||
var generatedFiles = 0;
|
||
|
||
for (final entry in modelFiles.entries) {
|
||
final filePath = '$modelsDir/${entry.key}';
|
||
if (_config.shouldSkipFile(filePath)) {
|
||
progress('跳过文件: $filePath');
|
||
continue;
|
||
}
|
||
await FileUtils.writeFile(filePath, entry.value);
|
||
success('模型文件已保存到: $filePath');
|
||
generatedFiles++;
|
||
}
|
||
|
||
return generatedFiles;
|
||
}
|
||
|
||
Future<int> _generateApis(
|
||
SwaggerDocument document,
|
||
String apiDir,
|
||
String modelsDir,
|
||
LogCallback progress,
|
||
LogCallback success,
|
||
) async {
|
||
progress('正在按版本和tags分组生成Retrofit风格API接口...');
|
||
|
||
await FileUtils.ensureDirectoryExists(apiDir);
|
||
final pathsByVersion = _groupPathsByVersion(document);
|
||
|
||
progress(
|
||
'检测到 ${pathsByVersion.keys.length} 个版本: '
|
||
'${pathsByVersion.keys.join(", ")}',
|
||
);
|
||
|
||
final versionedFiles = await _buildVersionedApis(
|
||
document,
|
||
pathsByVersion,
|
||
progress,
|
||
);
|
||
|
||
var generatedFiles = 0;
|
||
generatedFiles += await _writeVersionedApis(
|
||
apiDir,
|
||
versionedFiles,
|
||
progress,
|
||
success,
|
||
);
|
||
|
||
generatedFiles += await _writeMainApiFile(
|
||
apiDir,
|
||
versionedFiles,
|
||
success,
|
||
);
|
||
|
||
generatedFiles += await _writeParameterEntities(
|
||
document,
|
||
modelsDir,
|
||
success,
|
||
progress,
|
||
);
|
||
|
||
return generatedFiles;
|
||
}
|
||
|
||
Map<String, List<ApiPath>> _groupPathsByVersion(SwaggerDocument document) {
|
||
final pathsByVersion = <String, List<ApiPath>>{};
|
||
for (final path in document.paths.values) {
|
||
final version = _extractVersionFromPath(path.path);
|
||
pathsByVersion.putIfAbsent(version, () => []).add(path);
|
||
}
|
||
return pathsByVersion;
|
||
}
|
||
|
||
Future<Map<String, Map<String, String>>> _buildVersionedApis(
|
||
SwaggerDocument document,
|
||
Map<String, List<ApiPath>> pathsByVersion,
|
||
LogCallback progress,
|
||
) async {
|
||
final versionedFiles = <String, Map<String, String>>{};
|
||
final apiClientClassName = _config.apiClientClassName;
|
||
|
||
for (final versionEntry in pathsByVersion.entries) {
|
||
final version = versionEntry.key;
|
||
final versionPaths = versionEntry.value;
|
||
|
||
progress(' 正在生成 $version 版本 API（${versionPaths.length} 个接口）...');
|
||
|
||
final versionTags = versionPaths.expand((p) => p.tags).toSet();
|
||
final versionControllers = {
|
||
for (final tag in versionTags)
|
||
if (document.controllers.containsKey(tag))
|
||
tag: document.controllers[tag]!,
|
||
};
|
||
|
||
final versionDocument = SwaggerDocument(
|
||
title: document.title,
|
||
description: document.description,
|
||
version: document.version,
|
||
paths: {
|
||
for (final p in versionPaths)
|
||
SwaggerDocument.buildPathKey(p.path, p.method): p,
|
||
},
|
||
models: document.models,
|
||
controllers: versionControllers,
|
||
);
|
||
|
||
final generator = RetrofitApiGenerator(
|
||
className: apiClientClassName,
|
||
)
|
||
..document = versionDocument
|
||
..ensureParameterEntitiesGenerated();
|
||
|
||
final tagApiFiles = generator.generateApiFilesByTags();
|
||
versionedFiles[version] = {};
|
||
|
||
for (final entry in tagApiFiles.entries) {
|
||
final fileName = entry.key;
|
||
var code = entry.value;
|
||
code = _addVersionSuffixToCode(code, version);
|
||
versionedFiles[version]![fileName] = code;
|
||
}
|
||
}
|
||
|
||
return versionedFiles;
|
||
}
|
||
|
||
Future<int> _writeVersionedApis(
|
||
String apiDir,
|
||
Map<String, Map<String, String>> versionedFiles,
|
||
LogCallback progress,
|
||
LogCallback success,
|
||
) async {
|
||
var generatedFiles = 0;
|
||
|
||
for (final versionEntry in versionedFiles.entries) {
|
||
final version = versionEntry.key;
|
||
final files = versionEntry.value;
|
||
final versionDir = '$apiDir/$version';
|
||
|
||
if (_config.shouldSkipFile(versionDir)) {
|
||
progress('跳过版本目录: $versionDir');
|
||
continue;
|
||
}
|
||
|
||
await FileUtils.ensureDirectoryExists(versionDir);
|
||
|
||
for (final fileEntry in files.entries) {
|
||
final fileName = fileEntry.key;
|
||
final code = fileEntry.value;
|
||
final filePath = '$versionDir/$fileName';
|
||
|
||
if (_config.shouldSkipFile(filePath)) {
|
||
progress('跳过文件: $filePath');
|
||
continue;
|
||
}
|
||
|
||
await FileUtils.writeFile(filePath, code);
|
||
success('API接口文件已保存到: $filePath');
|
||
generatedFiles++;
|
||
}
|
||
|
||
if (!_config.shouldSkipFile(versionDir)) {
|
||
await _generateVersionIndexFile(versionDir, files.keys.toList());
|
||
success('$version/index.dart 已生成');
|
||
}
|
||
}
|
||
|
||
return generatedFiles;
|
||
}
|
||
|
||
Future<int> _writeMainApiFile(
|
||
String apiDir,
|
||
Map<String, Map<String, String>> versionedFiles,
|
||
LogCallback success,
|
||
) async {
|
||
final apiClientFileName = _config.apiClientFileName;
|
||
final mainCode = _generateVersionedApiClient(versionedFiles);
|
||
final mainFilePath = '$apiDir/$apiClientFileName.dart';
|
||
|
||
if (!_config.shouldSkipFile(mainFilePath)) {
|
||
await FileUtils.writeFile(mainFilePath, mainCode);
|
||
success('主API接口文件已保存到: $mainFilePath');
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
Future<int> _writeParameterEntities(
|
||
SwaggerDocument document,
|
||
String modelsDir,
|
||
LogCallback success,
|
||
LogCallback progress,
|
||
) async {
|
||
final apiClientClassName = _config.apiClientClassName;
|
||
final lastGenerator = RetrofitApiGenerator(
|
||
className: apiClientClassName,
|
||
)
|
||
..document = document
|
||
..ensureParameterEntitiesGenerated();
|
||
|
||
final parameterEntityFiles = lastGenerator.generateParameterEntityFiles();
|
||
if (parameterEntityFiles.isEmpty) {
|
||
return 0;
|
||
}
|
||
|
||
final parametersDir = '$modelsDir/parameters';
|
||
await FileUtils.ensureDirectoryExists(parametersDir);
|
||
var generatedFiles = 0;
|
||
|
||
for (final entry in parameterEntityFiles.entries) {
|
||
final filePath = '$parametersDir/${entry.key}';
|
||
|
||
if (_config.shouldSkipFile(filePath)) {
|
||
progress('跳过文件: $filePath');
|
||
continue;
|
||
}
|
||
|
||
await FileUtils.writeFile(filePath, entry.value);
|
||
success('参数实体类文件已保存到: $filePath');
|
||
generatedFiles++;
|
||
}
|
||
|
||
await _generateSubDirectoryIndexFile(parametersDir, success);
|
||
return generatedFiles;
|
||
}
|
||
|
||
Future<void> _regenerateModelsIndex(
|
||
String modelsDir,
|
||
LogCallback success,
|
||
) async {
|
||
final allFiles = await _getAllModelFiles(modelsDir);
|
||
final indexContent = _generateUpdatedIndexFile(allFiles);
|
||
final indexPath = '$modelsDir/index.dart';
|
||
await FileUtils.writeFile(indexPath, indexContent);
|
||
success('index.dart 文件已更新');
|
||
}
|
||
|
||
Future<List<String>> _getAllModelFiles(String modelsDir) async {
|
||
try {
|
||
final directory = Directory(modelsDir);
|
||
if (!directory.existsSync()) {
|
||
return [];
|
||
}
|
||
|
||
final files = directory.listSync();
|
||
final exportPaths = <String>[];
|
||
|
||
for (final entity in files) {
|
||
if (entity is Directory) {
|
||
final dirName = path.basename(entity.path);
|
||
final subIndexPath = path.join(entity.path, 'index.dart');
|
||
if (File(subIndexPath).existsSync()) {
|
||
exportPaths.add('$dirName/index.dart');
|
||
}
|
||
} else if (entity is File && entity.path.endsWith('.dart')) {
|
||
final fileName = path.basename(entity.path);
|
||
if (fileName != 'index.dart' && !fileName.endsWith('.g.dart')) {
|
||
exportPaths.add(fileName);
|
||
}
|
||
}
|
||
}
|
||
|
||
exportPaths.sort((a, b) {
|
||
final aIsDir = a.contains('/');
|
||
final bIsDir = b.contains('/');
|
||
if (aIsDir && !bIsDir) return -1;
|
||
if (!aIsDir && bIsDir) return 1;
|
||
return a.compareTo(b);
|
||
});
|
||
|
||
return exportPaths;
|
||
} on Exception catch (e, stackTrace) {
|
||
appLogger.severe('获取模型文件列表失败', e, stackTrace);
|
||
return [];
|
||
}
|
||
}
|
||
|
||
Future<void> _generateSubDirectoryIndexFile(
|
||
String subDir,
|
||
LogCallback success,
|
||
) async {
|
||
final directory = Directory(subDir);
|
||
if (!directory.existsSync()) return;
|
||
|
||
final dirName = path.basename(subDir);
|
||
final files = directory.listSync();
|
||
final dartFiles = <String>[];
|
||
|
||
for (final entity in files) {
|
||
if (entity is File && entity.path.endsWith('.dart')) {
|
||
final fileName = path.basename(entity.path);
|
||
if (fileName != 'index.dart' && !fileName.endsWith('.g.dart')) {
|
||
final filePath = path.join(subDir, fileName);
|
||
if (!_config.shouldSkipFile(filePath)) {
|
||
dartFiles.add(fileName);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
dartFiles.sort();
|
||
|
||
final buffer = StringBuffer()
|
||
..writeln('// 模型导出文件')
|
||
..writeln('// 基于 Swagger API 文档: ')
|
||
..writeln('// 由 xy_swagger_generator by max 生成')
|
||
..writeln('// Copyright (C) 2025 YuanXuan. All rights reserved.')
|
||
..writeln()
|
||
..writeln()
|
||
..writeln('library;')
|
||
..writeln();
|
||
|
||
for (final fileName in dartFiles) {
|
||
buffer.writeln("export '$fileName';");
|
||
}
|
||
|
||
final indexPath = path.join(subDir, 'index.dart');
|
||
await FileUtils.writeFile(indexPath, buffer.toString());
|
||
success('$dirName/index.dart 已生成，包含 ${dartFiles.length} 个文件');
|
||
}
|
||
|
||
String _generateUpdatedIndexFile(List<String> fileNames) {
|
||
final buffer = StringBuffer()
|
||
..writeln('// API 模型导出文件')
|
||
..writeln('// 基于 Swagger API 文档: ')
|
||
..writeln('// 由 xy_swagger_generator by max 生成')
|
||
..writeln('// Copyright (C) 2025 YuanXuan. All rights reserved.')
|
||
..writeln()
|
||
..writeln('library;')
|
||
..writeln();
|
||
|
||
final baseResultImport = SwaggerConfig.baseResultImport;
|
||
final basePageResultImport = SwaggerConfig.basePageResultImport;
|
||
|
||
if (baseResultImport.isNotEmpty) {
|
||
buffer.writeln("export '$baseResultImport';");
|
||
}
|
||
if (basePageResultImport.isNotEmpty) {
|
||
buffer.writeln("export '$basePageResultImport';");
|
||
}
|
||
|
||
if ((baseResultImport.isNotEmpty || basePageResultImport.isNotEmpty) &&
|
||
fileNames.isNotEmpty) {
|
||
buffer.writeln();
|
||
}
|
||
|
||
for (final fileName in fileNames) {
|
||
buffer.writeln("export '$fileName';");
|
||
}
|
||
|
||
return buffer.toString();
|
||
}
|
||
|
||
Future<void> _generateSummary(
|
||
SwaggerDocument document,
|
||
String outputDir,
|
||
) async {
|
||
final summary = StringBuffer()
|
||
..writeln('# 代码生成摘要')
|
||
..writeln()
|
||
..writeln('**API标题**: ${document.title}')
|
||
..writeln('**API版本**: ${document.version}')
|
||
..writeln('**生成时间**: ${DateTime.now().toIso8601String()}')
|
||
..writeln()
|
||
..writeln('## 统计信息')
|
||
..writeln('- 控制器数量: ${document.controllers.length}')
|
||
..writeln('- API路径数量: ${document.paths.length}')
|
||
..writeln('- 数据模型数量: ${document.models.length}')
|
||
..writeln()
|
||
..writeln('## 控制器列表');
|
||
document.controllers.forEach((name, controller) {
|
||
summary.writeln(
|
||
'- **$name**: ${controller.description} '
|
||
'(${controller.paths.length} 个路径)',
|
||
);
|
||
});
|
||
|
||
await FileUtils.writeFile('$outputDir/SUMMARY.md', summary.toString());
|
||
}
|
||
|
||
String _extractVersionFromPath(String path) {
|
||
final pattern = _config.versionExtractionPattern;
|
||
final defaultVersion = _config.defaultVersion;
|
||
|
||
try {
|
||
final versionMatch = RegExp(pattern).firstMatch(path);
|
||
if (versionMatch != null && versionMatch.groupCount > 0) {
|
||
return 'v${versionMatch.group(1)}';
|
||
}
|
||
} on FormatException {
|
||
const defaultPattern = r'/api/v(\d+)/';
|
||
final versionMatch = RegExp(defaultPattern).firstMatch(path);
|
||
if (versionMatch != null) {
|
||
return 'v${versionMatch.group(1)}';
|
||
}
|
||
}
|
||
|
||
return defaultVersion;
|
||
}
|
||
|
||
String _addVersionSuffixToCode(String code, String version) {
|
||
if (version == 'v1') {
|
||
return code;
|
||
}
|
||
|
||
final versionUpper = version.toUpperCase();
|
||
var updatedCode = code;
|
||
|
||
updatedCode = updatedCode.replaceAllMapped(
|
||
RegExp(r'abstract class (\w+Api)\b'),
|
||
(match) => 'abstract class ${match.group(1)}$versionUpper',
|
||
);
|
||
|
||
updatedCode = updatedCode.replaceAllMapped(
|
||
RegExp(r'factory (\w+Api)\('),
|
||
(match) => 'factory ${match.group(1)}$versionUpper(',
|
||
);
|
||
|
||
updatedCode = updatedCode.replaceAllMapped(
|
||
RegExp(r'= _(\w+Api);'),
|
||
(match) => '= _${match.group(1)}$versionUpper;',
|
||
);
|
||
|
||
updatedCode = updatedCode.replaceAllMapped(
|
||
RegExp(r"part '(\w+)\.g\.dart';"),
|
||
(match) => "part '${match.group(1)}.g.dart';",
|
||
);
|
||
|
||
updatedCode = updatedCode.replaceAllMapped(
|
||
RegExp(r"import '../(\w+_api)\.dart';"),
|
||
(match) => "import '../$version/${match.group(1)}.dart';",
|
||
);
|
||
|
||
return updatedCode;
|
||
}
|
||
|
||
String _generateVersionedApiClient(
|
||
Map<String, Map<String, String>> versionedFiles,
|
||
) {
|
||
final buffer = StringBuffer()
|
||
..writeln('// 统一 API 客户端')
|
||
..writeln('// 支持多版本 API 管理')
|
||
..writeln('// 由 xy_swagger_generator by max 生成')
|
||
..writeln('// Copyright (C) 2025 YuanXuan. All rights reserved.')
|
||
..writeln()
|
||
..writeln("import 'package:dio/dio.dart';")
|
||
..writeln();
|
||
|
||
final apiClasses = <String, Set<String>>{};
|
||
|
||
for (final versionEntry in versionedFiles.entries) {
|
||
final version = versionEntry.key;
|
||
final files = versionEntry.value;
|
||
apiClasses[version] = {};
|
||
|
||
for (final entry in files.entries) {
|
||
final code = entry.value;
|
||
final extracted = _extractApiClassNamesFromCode(code);
|
||
if (extracted.isNotEmpty) {
|
||
apiClasses[version]!.addAll(extracted.toSet());
|
||
continue;
|
||
}
|
||
|
||
final fileName = entry.key;
|
||
final className = fileName
|
||
.replaceAll('.dart', '')
|
||
.split('_')
|
||
.map(
|
||
(word) => word.isEmpty
|
||
? ''
|
||
: (word[0].toUpperCase() + word.substring(1)),
|
||
)
|
||
.join();
|
||
apiClasses[version]!.add(className);
|
||
}
|
||
}
|
||
|
||
final versions = apiClasses.keys.toList()..sort();
|
||
for (final version in versions) {
|
||
buffer.writeln("import '$version/index.dart';");
|
||
}
|
||
|
||
buffer
|
||
..writeln()
|
||
..writeln('/// 统一 API 客户端');
|
||
|
||
final apiClientClassName = _config.apiClientClassName;
|
||
buffer
|
||
..writeln('/// 支持多版本 API 访问')
|
||
..writeln('class $apiClientClassName {')
|
||
..writeln(' final Dio _dio;')
|
||
..writeln();
|
||
|
||
for (final versionEntry in apiClasses.entries) {
|
||
final version = versionEntry.key;
|
||
final versionUpper = version == 'v1' ? '' : version.toUpperCase();
|
||
|
||
for (final className in versionEntry.value) {
|
||
final suffix = version == 'v1' ? '' : versionUpper;
|
||
buffer.writeln(
|
||
' late final $className$suffix '
|
||
'_${_toLowerCamelCase(className)}$suffix;',
|
||
);
|
||
}
|
||
}
|
||
|
||
buffer
|
||
..writeln()
|
||
..writeln(' $apiClientClassName(this._dio) {')
|
||
..writeln(' _initApis();')
|
||
..writeln(' }')
|
||
..writeln()
|
||
..writeln(' void _initApis() {');
|
||
|
||
for (final versionEntry in apiClasses.entries) {
|
||
final version = versionEntry.key;
|
||
final versionUpper = version == 'v1' ? '' : version.toUpperCase();
|
||
|
||
for (final className in versionEntry.value) {
|
||
final fieldName = _toLowerCamelCase(className);
|
||
final suffix = version == 'v1' ? '' : versionUpper;
|
||
buffer.writeln(' _$fieldName$suffix = $className$suffix(_dio);');
|
||
}
|
||
}
|
||
|
||
buffer
|
||
..writeln(' }')
|
||
..writeln()
|
||
..writeln(' // ========== 版本化 API 访问 ==========')
|
||
..writeln();
|
||
|
||
for (final versionEntry in apiClasses.entries) {
|
||
final version = versionEntry.key;
|
||
final versionUpper = version == 'v1' ? '' : version.toUpperCase();
|
||
final versionLabel =
|
||
version == 'v1' ? 'V1（默认版本）' : '${version.toUpperCase()} 版本';
|
||
|
||
buffer.writeln(' /// $versionLabel API');
|
||
for (final className in versionEntry.value) {
|
||
final fieldName = _toLowerCamelCase(className);
|
||
final suffix = version == 'v1' ? '' : versionUpper;
|
||
buffer.writeln(
|
||
' $className$suffix get $fieldName$suffix => _$fieldName$suffix;',
|
||
);
|
||
}
|
||
buffer.writeln();
|
||
}
|
||
|
||
buffer.writeln('}');
|
||
return buffer.toString();
|
||
}
|
||
|
||
List<String> _extractApiClassNamesFromCode(String code) {
|
||
try {
|
||
final regex = RegExp(r'abstract\s+class\s+(\w+Api)\b');
|
||
final matches = regex.allMatches(code);
|
||
if (matches.isEmpty) return const [];
|
||
return matches.map((m) => m.group(1)!).toList();
|
||
} on FormatException {
|
||
return const [];
|
||
}
|
||
}
|
||
|
||
String _toLowerCamelCase(String className) {
|
||
final name = className.replaceAll('Api', '');
|
||
return name[0].toLowerCase() + name.substring(1);
|
||
}
|
||
|
||
Future<void> _generateVersionIndexFile(
|
||
String versionDir,
|
||
List<String> fileNames,
|
||
) async {
|
||
final buffer = StringBuffer()
|
||
..writeln('// API 接口导出文件')
|
||
..writeln('// 由 xy_swagger_generator by max 生成')
|
||
..writeln('// Copyright (C) 2025 YuanXuan. All rights reserved.')
|
||
..writeln();
|
||
|
||
final sortedFiles = fileNames.toList()..sort();
|
||
for (final fileName in sortedFiles) {
|
||
buffer.writeln("export '$fileName';");
|
||
}
|
||
|
||
final indexPath = '$versionDir/index.dart';
|
||
await FileUtils.writeFile(indexPath, buffer.toString());
|
||
}
|
||
}
|