run method

@override Future<void> run()

Runs this command.

The return value is wrapped in a Future if necessary and returned by CommandRunner.runCommand.

Implementation

@override
Future<void> run() async {
  /// Запрашиваем ссылку на swagger.json
  final swaggerUrl = getUserInput<String>(
    helpPhrase: "Введите ссылку на swagger док в json-формате",
    defaultValue: "",
  );

  final json = await http.get(Uri.parse(swaggerUrl), headers: {"Accept": "application/json"});

  final Map<String, dynamic> jsonMap = jsonDecode(json.body);

  /// Сваггер-док в структуре дарта
  final doc = APIDocument.fromMap(jsonMap);

  /// Префикс к методам в сваггере
  final prefix = getUserInput<String>(
    helpPhrase: "Префикс к методам в сваггере",
    defaultValue: "",
  );

  /// Запрашиваем путь для папки, куда будут генерироваться модели
  final currentDirectory = "models";
  final pathToFolder = getUserInput<String>(
    helpPhrase: "Введите путь для генерации моделей",
    defaultValue: currentDirectory,
  );

  /// Словарь с папкой и методами из этой папки
  final Map<String, List<Operation>> foldersMap = {};

  doc.paths?.forEach(
    (key, value) {
      /// Название метода без префикса
      final methodWithoutPrefix = _getSnakeCaseFolderPath(key, prefix);

      /// Название папки
      final folderName = methodWithoutPrefix.split('/').first;

      /// Название метода
      final methodName = methodWithoutPrefix.split('/').join('_');

      // Фильтруем на null
      final entries = value?.operations.entries
              .where((element) => element.value != null)
              .map((e) => MapEntry(e.key, e.value as APIOperation))
              .toList() ??
          [];

      final operations = entries
          .map((e) => Operation(
                operation: e.value,
                folderName: methodName,
                methodType: e.key,
              ))
          .toList();

      if (foldersMap.containsKey(folderName)) {
        foldersMap[folderName]!.addAll(operations);
      } else {
        foldersMap.putIfAbsent(folderName, () => operations);
      }
    },
  );

  for (final folder in foldersMap.entries) {
    final rootFolder = await Directory('$pathToFolder/${folder.key}').create(recursive: true);

    for (final operation in folder.value) {
      final operationFolder =
          await Directory('${rootFolder.path}/${operation.prefixSnakeCase}').create();
      final apiOperation = operation.operation;

      // Обработка модели реквеста (query)
      if (apiOperation.parameters?.isNotEmpty ?? false) {
        final params = apiOperation.parameters!;
        final fileName = "${operation.prefixSnakeCase}_request";
        final fileNameCamelCase = "${operation.prefixPascalCase}Request";
        final nestedModelName = "${operation.prefixPascalCase}Req";
        final file = await File("${operationFolder.path}/$fileName.dart").create();
        await file.writeAsString(
          generateQueryModel(
            filename: fileName,
            filenameCamelCase: fileNameCamelCase,
            nestedModelName: nestedModelName,
            parameters: params,
            comment: apiOperation.summary,
          ),
        );
      }

      // Обработка модели реквеста (body)
      if (apiOperation.requestBody?.content?.containsKey("application/json") ?? false) {
        final rootSchema = apiOperation.requestBody!.content!["application/json"]!.schema;
        if (rootSchema != null) {
          await generateBodyModel(
            rootSchema: rootSchema,
            directoryPath: operationFolder.path,
            modelType: BodyModelType(ModelType.request),
            operation: operation,
          );
        }
      }

      // Обработка модели респонса
      if (apiOperation.responses?.containsKey('200') ?? false) {
        final response = apiOperation.responses!['200']!;
        if (response.content?.containsKey("application/json") ?? false) {
          final rootSchema = response.content!["application/json"]!.schema;
          if (rootSchema != null) {
            await generateBodyModel(
              rootSchema: rootSchema,
              directoryPath: operationFolder.path,
              modelType: BodyModelType(ModelType.response),
              operation: operation,
            );
          }
        }
      }
    }
  }
}