Skip to content

基于自定义规则的番剧采集APP,支持流媒体在线观看,支持弹幕,支持实时超分辨率。

17.5 KB
Raw Blame
import 'dart:convert';

import 'package:json_path/json_path.dart';
import 'package:kazumi/modules/roads/road_module.dart';
import 'package:kazumi/modules/search/plugin_search_module.dart';
import 'package:kazumi/plugins/api_rule_config.dart';
import 'package:kazumi/services/plugin/rule_engine_models.dart';
import 'package:kazumi/utils/episode_url.dart';

class ApiRuleFormatException implements Exception {
  const ApiRuleFormatException(this.message);

  final String message;

  @override
  String toString() => 'ApiRuleFormatException: $message';
}

class RestrictedJsonPath {
  const RestrictedJsonPath._();

  static void validate(String expression) {
    if (expression.isEmpty || !expression.startsWith(r'$')) {
      throw ApiRuleFormatException('JSONPath 必须以 \$ 开头: $expression');
    }
    var index = 1;
    while (index < expression.length) {
      final char = expression[index];
      if (char == '.') {
        index++;
        final start = index;
        while (index < expression.length &&
            RegExp(r'[A-Za-z0-9_$-]').hasMatch(expression[index])) {
          index++;
        }
        if (index == start) {
          throw ApiRuleFormatException('不支持的 JSONPath: $expression');
        }
        continue;
      }
      if (char == '[') {
        final end = _findBracketEnd(expression, index);
        final content = expression.substring(index + 1, end).trim();
        final isIndex = RegExp(r'^\d+$').hasMatch(content);
        final isWildcard = content == '*';
        final isQuoted = content.length >= 2 &&
            ((content.startsWith("'") && content.endsWith("'")) ||
                (content.startsWith('"') && content.endsWith('"')));
        if (!isIndex && !isWildcard && !isQuoted) {
          throw ApiRuleFormatException('不支持的 JSONPath 片段: [$content]');
        }
        index = end + 1;
        continue;
      }
      throw ApiRuleFormatException('不支持的 JSONPath: $expression');
    }
  }

  static int _findBracketEnd(String expression, int start) {
    String? quote;
    var escaped = false;
    for (var i = start + 1; i < expression.length; i++) {
      final char = expression[i];
      if (escaped) {
        escaped = false;
        continue;
      }
      if (char == '\\') {
        escaped = true;
        continue;
      }
      if (quote != null) {
        if (char == quote) quote = null;
        continue;
      }
      if (char == "'" || char == '"') {
        quote = char;
        continue;
      }
      if (char == ']') return i;
    }
    throw ApiRuleFormatException('JSONPath 缺少 ]: $expression');
  }

  static List<Object?> read(dynamic document, String expression) {
    validate(expression);
    try {
      return JsonPath(expression).readValues(document).toList();
    } catch (error) {
      throw ApiRuleFormatException('JSONPath 解析失败 $expression: $error');
    }
  }

  static Object? readFirst(dynamic document, String expression) {
    final values = read(document, expression);
    return values.isEmpty ? null : values.first;
  }
}

/// Executes API request templates and parses supported JSON response shapes.
class ApiRuleStrategy {
  const ApiRuleStrategy();

  dynamic decodeResponse(String raw) {
    try {
      return jsonDecode(raw);
    } on FormatException catch (error) {
      throw ApiRuleFormatException('API 响应不是有效 JSON: ${error.message}');
    }
  }

  PreparedRuleRequest prepareRequest(
    ApiRequestConfig config,
    Map<String, Object?> variables,
  ) {
    final method = config.method.toUpperCase();
    if (method != 'GET' && method != 'POST') {
      throw ApiRuleFormatException('仅支持 GET/POST,当前为 $method');
    }
    if (config.url.trim().isEmpty) {
      throw const ApiRuleFormatException('API 请求 URL 不能为空');
    }
    final url = _renderTemplate(config.url.trim(), variables, encode: true);
    final uri = Uri.tryParse(url);
    if (uri == null || !uri.hasScheme || uri.host.isEmpty) {
      throw ApiRuleFormatException('API 请求 URL 无效: $url');
    }
    final hasBody = method == 'POST' && config.bodyType != ApiBodyType.none;
    return PreparedRuleRequest(
      method: method,
      url: url,
      headers: _renderMap(config.headers, variables),
      query: _renderMap(config.query, variables),
      bodyType: config.bodyType,
      body: hasBody ? _renderValue(config.body, variables) : null,
      includeCookies: true,
    );
  }

  /// Validates all JSONPath expressions in a search rule. Also used by the
  /// plugin editor to reject invalid rules before saving.
  void validateSearchConfig(ApiSearchConfig config) {
    RestrictedJsonPath.validate(config.listPath);
    RestrictedJsonPath.validate(config.namePath);
    RestrictedJsonPath.validate(config.sourcePath);
    final template = config.sourceTemplate;
    if (template.isNotEmpty && !template.contains('@source')) {
      throw const ApiRuleFormatException('详情页地址模板必须引用 @source');
    }
  }

  RuleSearchParseResult parseSearch(String raw, ApiSearchConfig config) {
    validateSearchConfig(config);
    final document = decodeResponse(raw);
    final nodes = RestrictedJsonPath.read(document, config.listPath);
    final template = config.sourceTemplate;
    final results = <SearchItem>[];
    final fragments = <String>[];
    final diagnostics = <String>[];
    for (var index = 0; index < nodes.length; index++) {
      final node = nodes[index];
      try {
        final name = _stringValue(
          RestrictedJsonPath.readFirst(node, config.namePath),
        );
        final source = _stringValue(
          RestrictedJsonPath.readFirst(node, config.sourcePath),
        );
        if (name.isEmpty || source.isEmpty) {
          diagnostics.add('搜索节点 $index 缺少名称或来源,已跳过');
          continue;
        }
        // Plain replacement so @source may follow a letter (`/GV@source`).
        final src = template.isEmpty
            ? source
            : template.replaceAll('@source', Uri.encodeComponent(source));
        results.add(SearchItem(name: name, src: src));
        fragments.add(jsonEncode(node));
      } on ApiRuleFormatException {
        rethrow;
      } catch (error) {
        diagnostics.add('搜索节点 $index 解析失败: $error');
      }
    }
    return RuleSearchParseResult(
      items: results,
      matchedFragments: fragments,
      diagnostics: diagnostics,
    );
  }

  RuleChapterParseResult parseChapters(
    String raw,
    ApiChapterConfig config, {
    required String source,
    required String baseUrl,
  }) {
    validateChapterConfig(config);
    final document = decodeResponse(raw);
    final rootVariables = <String, Object?>{'source': source};
    for (final entry in config.variables.entries) {
      final value = RestrictedJsonPath.readFirst(document, entry.value);
      if (value == null) {
        throw ApiRuleFormatException(
          '章节响应变量 ${entry.key} 未匹配到值: ${entry.value}',
        );
      }
      rootVariables[entry.key] = value;
    }
    final diagnostics = <String>[];
    final roads = config.format == ApiChapterFormat.delimited
        ? _parseDelimited(
            document,
            config,
            rootVariables,
            baseUrl,
            diagnostics,
          )
        : _parseNested(
            document,
            config,
            rootVariables,
            baseUrl,
            diagnostics,
          );
    return RuleChapterParseResult(
      roads: roads,
      diagnostics: diagnostics,
    );
  }

  List<Road> _parseNested(
    dynamic document,
    ApiChapterConfig config,
    Map<String, Object?> rootVariables,
    String baseUrl,
    List<String> diagnostics,
  ) {
    final hasRoads = config.roadsPath.trim().isNotEmpty;
    final roadNodes = hasRoads
        ? RestrictedJsonPath.read(document, config.roadsPath)
        : <Object?>[document];
    final roads = <Road>[];
    for (var roadIndex = 0; roadIndex < roadNodes.length; roadIndex++) {
      final roadNode = roadNodes[roadIndex];
      try {
        final roadName = hasRoads && config.roadNamePath.trim().isNotEmpty
            ? _stringValue(
                RestrictedJsonPath.readFirst(roadNode, config.roadNamePath),
              )
            : '';
        final episodeNodes = RestrictedJsonPath.read(
          roadNode,
          config.episodesPath,
        );
        final urls = <String>[];
        final names = <String>[];
        for (var episodeIndex = 0;
            episodeIndex < episodeNodes.length;
            episodeIndex++) {
          try {
            final episodeNode = episodeNodes[episodeIndex];
            final episodeName = _stringValue(
              RestrictedJsonPath.readFirst(
                episodeNode,
                config.episodeNamePath,
              ),
            );
            final rawUrl = config.episodeUrlPath.trim().isEmpty
                ? ''
                : _stringValue(
                    RestrictedJsonPath.readFirst(
                      episodeNode,
                      config.episodeUrlPath,
                    ),
                  );
            final pageUrl = _resolveEpisodeUrl(
              config,
              rootVariables,
              rawUrl: rawUrl,
              roadIndex: roadIndex,
              episodeIndex: episodeIndex,
              baseUrl: baseUrl,
            );
            if (pageUrl.isEmpty) {
              diagnostics.add(
                '线路 $roadIndex 的剧集节点 $episodeIndex 缺少 URL,已跳过',
              );
              continue;
            }
            urls.add(pageUrl);
            names.add(
              episodeName.isEmpty ? '第${episodeIndex + 1}集' : episodeName,
            );
          } on ApiRuleFormatException {
            rethrow;
          } catch (error) {
            diagnostics.add(
              '线路 $roadIndex 的剧集节点 $episodeIndex 解析失败: $error',
            );
          }
        }
        if (urls.isEmpty) {
          diagnostics.add('线路节点 $roadIndex 没有有效剧集,已跳过');
          continue;
        }
        roads.add(
          Road(
            name: roadName.isEmpty
                ? '播放线路${roads.length + 1}'
                : roadName,
            data: urls,
            identifier: names,
          ),
        );
      } on ApiRuleFormatException {
        rethrow;
      } catch (error) {
        diagnostics.add('线路节点 $roadIndex 解析失败: $error');
      }
    }
    return roads;
  }

  List<Road> _parseDelimited(
    dynamic document,
    ApiChapterConfig config,
    Map<String, Object?> rootVariables,
    String baseUrl,
    List<String> diagnostics,
  ) {
    final namesValue = _stringValue(
      RestrictedJsonPath.readFirst(document, config.roadNamesPath),
    );
    final episodesValue = _stringValue(
      RestrictedJsonPath.readFirst(document, config.roadEpisodesPath),
    );
    if (episodesValue.isEmpty) return <Road>[];
    final roadNames = namesValue.split(config.roadSeparator);
    final roadGroups = episodesValue.split(config.roadSeparator);
    final roads = <Road>[];
    for (var roadIndex = 0; roadIndex < roadGroups.length; roadIndex++) {
      final urls = <String>[];
      final names = <String>[];
      final entries = roadGroups[roadIndex].split(config.episodeSeparator);
      for (var episodeIndex = 0;
          episodeIndex < entries.length;
          episodeIndex++) {
        final entry = entries[episodeIndex].trim();
        if (entry.isEmpty) continue;
        final separatorIndex = entry.indexOf(config.fieldSeparator);
        if (separatorIndex < 0) {
          diagnostics.add(
            '线路 $roadIndex 的剧集条目 $episodeIndex 缺少字段分隔符,已跳过',
          );
          continue;
        }
        final name = entry.substring(0, separatorIndex).trim();
        final rawUrl = entry
            .substring(separatorIndex + config.fieldSeparator.length)
            .trim();
        try {
          final pageUrl = _resolveEpisodeUrl(
            config,
            rootVariables,
            rawUrl: rawUrl,
            roadIndex: roadIndex,
            episodeIndex: episodeIndex,
            baseUrl: baseUrl,
          );
          if (pageUrl.isEmpty) {
            diagnostics.add(
              '线路 $roadIndex 的剧集条目 $episodeIndex 缺少 URL,已跳过',
            );
            continue;
          }
          urls.add(pageUrl);
          names.add(name.isEmpty ? '第${episodeIndex + 1}集' : name);
        } on ApiRuleFormatException {
          rethrow;
        } catch (error) {
          diagnostics.add(
            '线路 $roadIndex 的剧集条目 $episodeIndex 解析失败: $error',
          );
        }
      }
      if (urls.isEmpty) {
        diagnostics.add('线路 $roadIndex 没有有效剧集,已跳过');
        continue;
      }
      final configuredName =
          roadIndex < roadNames.length ? roadNames[roadIndex].trim() : '';
      roads.add(
        Road(
          name: configuredName.isEmpty
              ? '播放线路${roads.length + 1}'
              : configuredName,
          data: urls,
          identifier: names,
        ),
      );
    }
    return roads;
  }

  String _resolveEpisodeUrl(
    ApiChapterConfig config,
    Map<String, Object?> rootVariables, {
    required String rawUrl,
    required int roadIndex,
    required int episodeIndex,
    required String baseUrl,
  }) {
    final page = config.episodePage;
    if (page == null) return normalizeEpisodeUrl(baseUrl, rawUrl);
    if (page.url.trim().isEmpty) {
      throw const ApiRuleFormatException('播放页地址模板不能为空');
    }
    // The template language has no arithmetic, so both 0-based and 1-based
    // indices must be provided; @episodeUrl carries the raw value extracted
    // by episodeUrlPath and has no substitute.
    final variables = <String, Object?>{
      ...rootVariables,
      'episodeUrl': rawUrl,
      'roadIndex': roadIndex,
      'roadNumber': roadIndex + 1,
      'episodeIndex': episodeIndex,
      'episodeNumber': episodeIndex + 1,
    };
    final path = _renderTemplate(page.url, variables, encode: true);
    final uri = Uri.tryParse(path);
    if (uri == null) {
      throw ApiRuleFormatException('剧集页面 URL 无效: $path');
    }
    final renderedQuery = _renderMap(page.query, variables).map(
      (key, value) => MapEntry(key, value.toString()),
    );
    final mergedQuery = <String, String>{
      ...uri.queryParameters,
      ...renderedQuery,
    };
    return normalizeEpisodeUrl(
      baseUrl,
      uri.replace(queryParameters: mergedQuery).toString(),
    );
  }

  /// Validates the JSONPath expressions and format-specific invariants of a
  /// chapter rule. Also used by the plugin editor to reject invalid rules
  /// before saving.
  void validateChapterConfig(ApiChapterConfig config) {
    for (final path in config.variables.values) {
      RestrictedJsonPath.validate(path);
    }
    if (config.format == ApiChapterFormat.delimited) {
      RestrictedJsonPath.validate(config.roadNamesPath);
      RestrictedJsonPath.validate(config.roadEpisodesPath);
      if (config.roadSeparator.isEmpty ||
          config.episodeSeparator.isEmpty ||
          config.fieldSeparator.isEmpty) {
        throw const ApiRuleFormatException('章节分隔符不能为空');
      }
      return;
    }

    if (config.roadsPath.trim().isNotEmpty) {
      RestrictedJsonPath.validate(config.roadsPath);
    }
    if (config.roadNamePath.trim().isNotEmpty) {
      RestrictedJsonPath.validate(config.roadNamePath);
    }
    RestrictedJsonPath.validate(config.episodesPath);
    RestrictedJsonPath.validate(config.episodeNamePath);
    if (config.episodeUrlPath.trim().isNotEmpty) {
      RestrictedJsonPath.validate(config.episodeUrlPath);
    } else if (config.episodePage == null) {
      throw const ApiRuleFormatException(
        '必须配置播放入口地址路径或播放页地址模板',
      );
    }
    if (config.episodePage != null && config.episodePage!.url.trim().isEmpty) {
      throw const ApiRuleFormatException('播放页地址模板不能为空');
    }
  }

  Map<String, dynamic> _renderMap(
    Map<String, dynamic> input,
    Map<String, Object?> variables,
  ) {
    return input.map(
      (key, value) => MapEntry(
        _renderTemplate(key, variables),
        _renderValue(value, variables),
      ),
    );
  }

  dynamic _renderValue(dynamic value, Map<String, Object?> variables) {
    if (value is String) {
      final exact = RegExp(r'^@([A-Za-z_][A-Za-z0-9_]*)$').firstMatch(value);
      if (exact != null) {
        final name = exact.group(1)!;
        if (!variables.containsKey(name)) {
          throw ApiRuleFormatException('缺少模板变量 @$name');
        }
        return variables[name];
      }
      return _renderTemplate(value, variables);
    }
    if (value is List) {
      return value.map((item) => _renderValue(item, variables)).toList();
    }
    if (value is Map) {
      return value.map(
        (key, item) => MapEntry(
          key.toString(),
          _renderValue(item, variables),
        ),
      );
    }
    return value;
  }

  String _renderTemplate(
    String template,
    Map<String, Object?> variables, {
    bool encode = false,
  }) {
    return template.replaceAllMapped(
      RegExp(r'(?<![A-Za-z0-9_])@([A-Za-z_][A-Za-z0-9_]*)'),
      (match) {
        final name = match.group(1)!;
        if (!variables.containsKey(name)) {
          throw ApiRuleFormatException('缺少模板变量 @$name');
        }
        final value = variables[name]?.toString() ?? '';
        return encode ? Uri.encodeComponent(value) : value;
      },
    );
  }

  String _stringValue(Object? value) {
    if (value == null) return '';
    return value is String ? value.trim() : value.toString();
  }
}