600 lines
19 KiB
Dart
600 lines
19 KiB
Dart
import 'package:dio/dio.dart';
|
|
|
|
import '../../core/http/dio_client.dart';
|
|
import '../models/artist_announcement.dart';
|
|
import '../models/artist_link.dart';
|
|
import '../models/artist_profile.dart';
|
|
import '../models/artist_tag.dart';
|
|
import '../models/artist_work_query.dart';
|
|
import '../models/post.dart';
|
|
import '../models/post_comment.dart';
|
|
import '../models/provider_health.dart';
|
|
import '../models/top_period_filter.dart';
|
|
import '../services/cloud_link_extractor.dart';
|
|
import 'content_provider.dart';
|
|
|
|
class KemonoProvider
|
|
implements ContentProvider, ArtistProvider, CommentProvider {
|
|
KemonoProvider({
|
|
required this.id,
|
|
required this.name,
|
|
required this.baseUrl,
|
|
required DioClient dioClient,
|
|
Map<String, String> queryParameters = const {},
|
|
}) : _dio = dioClient.dio,
|
|
_creatorDio = Dio(
|
|
BaseOptions(
|
|
baseUrl: queryParameters['creator_api_base'] ??
|
|
'https://kemono-api.mbaharip.com',
|
|
connectTimeout: const Duration(seconds: 15),
|
|
receiveTimeout: const Duration(seconds: 20),
|
|
headers: const {
|
|
'Accept': 'application/json',
|
|
'User-Agent': 'Lunaris/2.0.1 Flutter local booru browser',
|
|
},
|
|
),
|
|
);
|
|
|
|
@override
|
|
final String id;
|
|
|
|
@override
|
|
final String name;
|
|
|
|
@override
|
|
final String baseUrl;
|
|
|
|
final Dio _dio;
|
|
final Dio _creatorDio;
|
|
|
|
bool get _isCoomer =>
|
|
id.toLowerCase().contains('coomer') ||
|
|
baseUrl.toLowerCase().contains('coomer');
|
|
|
|
@override
|
|
Future<List<Post>> searchPosts({
|
|
required List<String> tags,
|
|
required int page,
|
|
int limit = 50,
|
|
String? rating,
|
|
TopPeriodFilter topPeriod = TopPeriodFilter.none,
|
|
}) async {
|
|
return const [];
|
|
}
|
|
|
|
@override
|
|
Future<Post?> getPost(String id) async => null;
|
|
|
|
@override
|
|
Future<ProviderHealth> checkHealth() async {
|
|
final startedAt = DateTime.now();
|
|
try {
|
|
await _creatorDio.get<dynamic>(
|
|
_creatorPath(),
|
|
queryParameters: {'page': 1, 'itemsPerPage': 1},
|
|
);
|
|
return ProviderHealth(
|
|
providerId: id,
|
|
status: ProviderStatus.online,
|
|
pingMs: DateTime.now().difference(startedAt).inMilliseconds,
|
|
lastCheckedAt: DateTime.now(),
|
|
apiVersion: _isCoomer ? 'coomer-artists' : 'kemono-artists',
|
|
);
|
|
} catch (error) {
|
|
return ProviderHealth(
|
|
providerId: id,
|
|
status: ProviderStatus.offline,
|
|
pingMs: DateTime.now().difference(startedAt).inMilliseconds,
|
|
lastCheckedAt: DateTime.now(),
|
|
errorMessage: error.toString(),
|
|
apiVersion: _isCoomer ? 'coomer-artists' : 'kemono-artists',
|
|
);
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<List<ArtistProfile>> listArtists({
|
|
String? service,
|
|
List<String>? services,
|
|
String? query,
|
|
int page = 1,
|
|
int limit = 30,
|
|
}) async {
|
|
final effectiveService =
|
|
services != null && services.length == 1 ? services.first : service;
|
|
List<ArtistProfile> list;
|
|
try {
|
|
final response = await _creatorDio.get<dynamic>(
|
|
effectiveService == null || effectiveService.isEmpty
|
|
? _creatorPath()
|
|
: '${_creatorPath()}/$effectiveService',
|
|
queryParameters: {
|
|
'page': page,
|
|
'itemsPerPage': limit.clamp(1, 100),
|
|
if (query != null && query.trim().isNotEmpty) 'keyword': query.trim(),
|
|
},
|
|
);
|
|
list = _rankArtists(_artistsFromResponse(response.data), query ?? '');
|
|
} catch (_) {
|
|
list = await _listArtistsFromPublicApi(
|
|
service: effectiveService,
|
|
query: query,
|
|
page: page,
|
|
limit: limit,
|
|
);
|
|
}
|
|
if (services != null && services.isNotEmpty) {
|
|
final sSet = services.map((s) => s.toLowerCase()).toSet();
|
|
list = list.where((a) => sSet.contains(a.service.toLowerCase())).toList();
|
|
}
|
|
return list;
|
|
}
|
|
|
|
@override
|
|
Future<List<ArtistProfile>> searchArtists(
|
|
String query, {
|
|
String? service,
|
|
List<String>? services,
|
|
int page = 1,
|
|
int limit = 30,
|
|
}) {
|
|
return listArtists(
|
|
service: service,
|
|
services: services,
|
|
query: query,
|
|
page: page,
|
|
limit: limit,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<List<Post>> getArtistPosts({
|
|
required ArtistWorkQuery query,
|
|
int page = 0,
|
|
int limit = 50,
|
|
}) async {
|
|
Object? lastError;
|
|
final paths = [
|
|
'/api/v1/${query.service}/user/${query.artistId}/posts',
|
|
'/api/v1/${query.service}/user/${query.artistId}',
|
|
];
|
|
for (final apiBase in _apiBaseCandidates()) {
|
|
for (final path in paths) {
|
|
try {
|
|
final response = await _getFromApiBase<dynamic>(
|
|
apiBase,
|
|
path,
|
|
queryParameters: {'o': page * limit},
|
|
);
|
|
final posts = _postItems(response.data);
|
|
final mapped = <Post>[];
|
|
for (final post in posts.whereType<Map>()) {
|
|
mapped.addAll(_postsFromArtistPost(
|
|
Map<String, dynamic>.from(post),
|
|
query: query,
|
|
mediaBaseUrl: apiBase,
|
|
));
|
|
}
|
|
if (mapped.isNotEmpty || posts.isEmpty) {
|
|
mapped.sort((a, b) => b.createdAt.compareTo(a.createdAt));
|
|
return mapped.take(limit).toList(growable: false);
|
|
}
|
|
} catch (error) {
|
|
lastError = error;
|
|
}
|
|
}
|
|
}
|
|
throw StateError(
|
|
'$name artist works are unavailable right now. Try again later. '
|
|
'${_shortError(lastError)}',
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<List<PostComment>> getArtistPostComments(
|
|
String service,
|
|
String artistId,
|
|
String postId,
|
|
) async {
|
|
Object? lastError;
|
|
final path = '/api/v1/$service/user/$artistId/post/$postId/comments';
|
|
for (final apiBase in _apiBaseCandidates()) {
|
|
try {
|
|
final response = await _getFromApiBase<dynamic>(apiBase, path);
|
|
return _commentsFromResponse(response.data, postId);
|
|
} catch (error) {
|
|
lastError = error;
|
|
}
|
|
}
|
|
throw StateError(
|
|
'$name comments are unavailable right now. ${_shortError(lastError)}',
|
|
);
|
|
}
|
|
|
|
@override
|
|
Future<List<PostComment>> getComments(String postId) async {
|
|
final parts = postId.split(':');
|
|
if (parts.length < 4) return const [];
|
|
return getArtistPostComments(parts[0], parts[1], parts[2]);
|
|
}
|
|
|
|
@override
|
|
Future<List<ArtistTag>> getArtistTags(
|
|
String service, String artistId) async =>
|
|
const [];
|
|
|
|
@override
|
|
Future<List<ArtistLink>> getArtistLinks(
|
|
String service, String artistId) async =>
|
|
const [];
|
|
|
|
@override
|
|
Future<List<ArtistAnnouncement>> getArtistAnnouncements(
|
|
String service, String artistId) async =>
|
|
const [];
|
|
|
|
String _creatorPath() => _isCoomer ? '/coomer' : '/kemono';
|
|
|
|
List<ArtistProfile> _artistsFromResponse(dynamic data) {
|
|
final items = data is Map ? data['data'] : data;
|
|
if (items is! List) return const [];
|
|
return items
|
|
.whereType<Map>()
|
|
.map((item) {
|
|
final json = Map<String, dynamic>.from(item);
|
|
final service = (json['service'] ?? '').toString();
|
|
final artistId =
|
|
(json['id'] ?? json['creator_id'] ?? json['user_id'] ?? '')
|
|
.toString();
|
|
final name = (json['name'] ??
|
|
json['display_name'] ??
|
|
json['username'] ??
|
|
artistId)
|
|
.toString();
|
|
final rawAvatar = (json['avatar'] ??
|
|
json['icon'] ??
|
|
json['image'] ??
|
|
json['avatar_url'] ??
|
|
'')
|
|
.toString();
|
|
return ArtistProfile(
|
|
id: artistId,
|
|
providerId: id,
|
|
service: service,
|
|
name: name,
|
|
displayName: name,
|
|
avatarUrl: _absoluteUrl(rawAvatar) ?? _iconUrl(service, artistId),
|
|
updatedAt: _dateFromAny(json['updated']),
|
|
postCount: (json['post_count'] as num?)?.toInt(),
|
|
url: '$baseUrl/$service/user/$artistId',
|
|
);
|
|
})
|
|
.where((artist) => artist.id.isNotEmpty)
|
|
.toList(growable: false);
|
|
}
|
|
|
|
Future<List<ArtistProfile>> _listArtistsFromPublicApi({
|
|
String? service,
|
|
String? query,
|
|
required int page,
|
|
required int limit,
|
|
}) async {
|
|
Object? lastError;
|
|
dynamic data;
|
|
for (final apiBase in _apiBaseCandidates()) {
|
|
try {
|
|
final response =
|
|
await _getFromApiBase<dynamic>(apiBase, '/api/v1/creators.txt');
|
|
data = response.data;
|
|
break;
|
|
} catch (error) {
|
|
lastError = error;
|
|
}
|
|
}
|
|
if (data == null) {
|
|
throw StateError(
|
|
'$name artist index is unavailable right now. ${_shortError(lastError)}',
|
|
);
|
|
}
|
|
final queryText = (query ?? '').trim().toLowerCase();
|
|
final offset = (page - 1).clamp(0, 999999) * limit;
|
|
final items = _artistsFromResponse({'data': data})
|
|
.where((artist) =>
|
|
(service == null || service.isEmpty || artist.service == service) &&
|
|
(queryText.isEmpty ||
|
|
artist.displayName.toLowerCase().contains(queryText) ||
|
|
artist.id.toLowerCase().contains(queryText)))
|
|
.toList(growable: false);
|
|
final ranked = _rankArtists(items, queryText);
|
|
return ranked.skip(offset).take(limit).toList(growable: false);
|
|
}
|
|
|
|
List<ArtistProfile> _rankArtists(List<ArtistProfile> artists, String query) {
|
|
final queryText = query.trim().toLowerCase();
|
|
final ranked = [...artists];
|
|
ranked.sort((a, b) {
|
|
final scoreA = _artistSearchScore(a, queryText);
|
|
final scoreB = _artistSearchScore(b, queryText);
|
|
if (scoreA != scoreB) return scoreB.compareTo(scoreA);
|
|
final updatedA = a.updatedAt ?? DateTime.fromMillisecondsSinceEpoch(0);
|
|
final updatedB = b.updatedAt ?? DateTime.fromMillisecondsSinceEpoch(0);
|
|
final updated = updatedB.compareTo(updatedA);
|
|
if (updated != 0) return updated;
|
|
final count = (b.postCount ?? 0).compareTo(a.postCount ?? 0);
|
|
if (count != 0) return count;
|
|
return a.displayName.compareTo(b.displayName);
|
|
});
|
|
return ranked;
|
|
}
|
|
|
|
int _artistSearchScore(ArtistProfile artist, String query) {
|
|
if (query.isEmpty) return 0;
|
|
final name = artist.displayName.toLowerCase();
|
|
final id = artist.id.toLowerCase();
|
|
if (name == query || id == query) return 100;
|
|
if (name.startsWith(query) || id.startsWith(query)) return 70;
|
|
if (name.contains(query) || id.contains(query)) return 40;
|
|
return 0;
|
|
}
|
|
|
|
List<dynamic> _postItems(dynamic data) {
|
|
if (data is List) return data;
|
|
if (data is Map) {
|
|
final results = data['results'];
|
|
if (results is List) return results;
|
|
final posts = data['posts'];
|
|
if (posts is List) return posts;
|
|
if (posts is Map) return _postItems(posts);
|
|
final dataItems = data['data'];
|
|
if (dataItems is List) return dataItems;
|
|
}
|
|
return const [];
|
|
}
|
|
|
|
List<Post> _postsFromArtistPost(
|
|
Map<String, dynamic> json, {
|
|
required ArtistWorkQuery query,
|
|
required String mediaBaseUrl,
|
|
}) {
|
|
final postId = (json['id'] ?? json['post_id'] ?? '').toString();
|
|
final title = (json['title'] ?? '').toString();
|
|
final published = _dateFromAny(json['published']) ??
|
|
_dateFromAny(json['added']) ??
|
|
_dateFromAny(json['edited']) ??
|
|
DateTime.fromMillisecondsSinceEpoch(0);
|
|
final postSource =
|
|
'$baseUrl/${query.service}/user/${query.artistId}/post/$postId';
|
|
final rawContent = (json['content'] ?? '').toString();
|
|
final embed = json['embed'] is Map ? Map<String, dynamic>.from(json['embed']) : null;
|
|
final cloudLinks = CloudLinkExtractor.extractLinks(
|
|
content: rawContent,
|
|
source: postSource,
|
|
embed: embed,
|
|
);
|
|
final cloudLinksJson = cloudLinks.map((e) => e.encode()).toList(growable: false);
|
|
final cleanDesc = CloudLinkExtractor.cleanCommentary(rawContent);
|
|
|
|
final files = <Map<String, dynamic>>[];
|
|
final file = json['file'];
|
|
if (file is Map && file.isNotEmpty) {
|
|
files.add(Map<String, dynamic>.from(file));
|
|
}
|
|
final attachments = json['attachments'];
|
|
if (attachments is List) {
|
|
files.addAll(attachments.whereType<Map>().map(Map<String, dynamic>.from));
|
|
}
|
|
|
|
// Support link-only posts where author uploaded files to cloud drives (MEGA, GDrive, etc.)
|
|
if (files.isEmpty && (cloudLinks.isNotEmpty || cleanDesc.isNotEmpty)) {
|
|
final stableId = '${query.service}:${query.artistId}:$postId:0';
|
|
final firstStreamable =
|
|
cloudLinks.where((l) => l.isStreamable).firstOrNull;
|
|
final firstLink = cloudLinks.isNotEmpty ? cloudLinks.first : null;
|
|
final fileUrl = firstStreamable?.directStreamUrl ?? firstLink?.url ?? '';
|
|
final tags = [
|
|
query.service,
|
|
query.artistName,
|
|
if (title.trim().isNotEmpty) title.trim(),
|
|
'cloud_mirror',
|
|
];
|
|
return [
|
|
Post(
|
|
id: stableId,
|
|
providerId: id,
|
|
providerName: name,
|
|
previewUrl: '',
|
|
sampleUrl: '',
|
|
fileUrl: fileUrl,
|
|
tags: tags,
|
|
rating: 'unknown',
|
|
width: 0,
|
|
height: 0,
|
|
source: postSource,
|
|
createdAt: published,
|
|
fileType: firstStreamable != null ? 'video' : 'link',
|
|
score: 0,
|
|
tagGroups: {
|
|
'artist': [query.artistName],
|
|
'meta': [query.service],
|
|
if (title.trim().isNotEmpty) 'copyright': [title.trim()],
|
|
if (cloudLinksJson.isNotEmpty) 'cloud_links': cloudLinksJson,
|
|
if (cleanDesc.isNotEmpty) 'description': [cleanDesc],
|
|
},
|
|
),
|
|
];
|
|
}
|
|
|
|
var index = 0;
|
|
return files
|
|
.map((file) {
|
|
final url = _mediaUrl(file, mediaBaseUrl: mediaBaseUrl);
|
|
final fileName =
|
|
(file['name'] ?? Uri.tryParse(url)?.pathSegments.last ?? '')
|
|
.toString();
|
|
final type = _fileType('$fileName $url');
|
|
final stableId =
|
|
'${query.service}:${query.artistId}:$postId:${index++}';
|
|
final tags = [
|
|
query.service,
|
|
query.artistName,
|
|
if (title.trim().isNotEmpty) title.trim(),
|
|
];
|
|
return Post(
|
|
id: stableId,
|
|
providerId: id,
|
|
providerName: name,
|
|
previewUrl: url,
|
|
sampleUrl: url,
|
|
fileUrl: url,
|
|
tags: tags,
|
|
rating: 'unknown',
|
|
width: 0,
|
|
height: 0,
|
|
source: postSource,
|
|
createdAt: published,
|
|
fileType: type,
|
|
score: 0,
|
|
tagGroups: {
|
|
'artist': [query.artistName],
|
|
'meta': [query.service],
|
|
if (title.trim().isNotEmpty) 'copyright': [title.trim()],
|
|
if (cloudLinksJson.isNotEmpty) 'cloud_links': cloudLinksJson,
|
|
if (cleanDesc.isNotEmpty) 'description': [cleanDesc],
|
|
},
|
|
);
|
|
})
|
|
.where((post) => post.fileUrl.isNotEmpty)
|
|
.toList(growable: false);
|
|
}
|
|
|
|
List<PostComment> _commentsFromResponse(dynamic data, String postId) {
|
|
final items = data is Map ? (data['comments'] ?? data['data']) : data;
|
|
if (items is! List) return const [];
|
|
return items
|
|
.whereType<Map>()
|
|
.map((item) {
|
|
final json = Map<String, dynamic>.from(item);
|
|
return PostComment(
|
|
id: (json['id'] ?? json['comment_id'] ?? '').toString(),
|
|
postId: postId,
|
|
providerId: id,
|
|
authorName: (json['author'] ??
|
|
json['username'] ??
|
|
json['user'] ??
|
|
json['creator_name'] ??
|
|
'user')
|
|
.toString(),
|
|
body: (json['content'] ?? json['body'] ?? json['comment'] ?? '')
|
|
.toString(),
|
|
createdAt: _dateFromAny(json['added']) ??
|
|
_dateFromAny(json['created_at']) ??
|
|
DateTime.fromMillisecondsSinceEpoch(0),
|
|
);
|
|
})
|
|
.where((comment) => comment.body.trim().isNotEmpty)
|
|
.toList(growable: false);
|
|
}
|
|
|
|
String _mediaUrl(
|
|
Map<String, dynamic> file, {
|
|
required String mediaBaseUrl,
|
|
}) {
|
|
final path = (file['path'] ?? file['url'] ?? '').toString();
|
|
if (path.isEmpty) return '';
|
|
final uri = Uri.tryParse(path);
|
|
if (uri != null && uri.hasScheme) return path;
|
|
if (path.startsWith('/data/')) {
|
|
return '$mediaBaseUrl$path';
|
|
}
|
|
if (path.startsWith('/')) {
|
|
return '$mediaBaseUrl/data$path';
|
|
}
|
|
return '$mediaBaseUrl/data/$path';
|
|
}
|
|
|
|
String? _iconUrl(String service, String artistId) {
|
|
if (service.isEmpty || artistId.isEmpty) return null;
|
|
final host = _isCoomer ? 'https://img.coomer.su' : 'https://img.kemono.su';
|
|
return '$host/icons/$service/$artistId';
|
|
}
|
|
|
|
String? _absoluteUrl(String value) {
|
|
final trimmed = value.trim();
|
|
if (trimmed.isEmpty) return null;
|
|
final uri = Uri.tryParse(trimmed);
|
|
if (uri != null && uri.hasScheme) return trimmed;
|
|
if (trimmed.startsWith('/')) return '$baseUrl$trimmed';
|
|
return '$baseUrl/$trimmed';
|
|
}
|
|
|
|
List<String> _apiBaseCandidates() {
|
|
final candidates = <String>[
|
|
baseUrl,
|
|
if (_isCoomer) ...[
|
|
'https://coomer.st',
|
|
'https://coomer.su',
|
|
] else ...[
|
|
'https://kemono.cr',
|
|
'https://kemono.su',
|
|
],
|
|
];
|
|
return candidates.map(_trimTrailingSlash).toSet().toList(growable: false);
|
|
}
|
|
|
|
Future<Response<T>> _getFromApiBase<T>(
|
|
String apiBase,
|
|
String path, {
|
|
Map<String, Object?> queryParameters = const {},
|
|
}) {
|
|
if (_trimTrailingSlash(apiBase) == _trimTrailingSlash(baseUrl)) {
|
|
return _dio.get<T>(path, queryParameters: queryParameters);
|
|
}
|
|
final dio = Dio(
|
|
BaseOptions(
|
|
baseUrl: apiBase,
|
|
connectTimeout: const Duration(seconds: 15),
|
|
receiveTimeout: const Duration(seconds: 25),
|
|
headers: const {
|
|
'Accept': 'application/json',
|
|
'User-Agent': 'Lunaris/2.0.1 Flutter local booru browser',
|
|
},
|
|
),
|
|
);
|
|
return dio.get<T>(path, queryParameters: queryParameters);
|
|
}
|
|
|
|
String _trimTrailingSlash(String value) =>
|
|
value.endsWith('/') ? value.substring(0, value.length - 1) : value;
|
|
|
|
String _shortError(Object? error) {
|
|
if (error == null) return '';
|
|
final message = error.toString();
|
|
if (message.length <= 160) return message;
|
|
return '${message.substring(0, 160)}...';
|
|
}
|
|
|
|
String _fileType(String value) {
|
|
final lower = value.toLowerCase().split('?').first;
|
|
if (lower.endsWith('.webm') || lower.endsWith('.mp4')) return 'video';
|
|
if (lower.endsWith('.gif')) return 'gif';
|
|
if (lower.endsWith('.swf')) return 'swf';
|
|
if (lower.endsWith('.png')) return 'png';
|
|
if (lower.endsWith('.jpg') ||
|
|
lower.endsWith('.jpeg') ||
|
|
lower.endsWith('.webp')) {
|
|
return 'photo';
|
|
}
|
|
return 'unknown';
|
|
}
|
|
|
|
DateTime? _dateFromAny(dynamic value) {
|
|
if (value == null) return null;
|
|
if (value is num) {
|
|
final raw = value.toInt();
|
|
if (raw > 9999999999) return DateTime.fromMillisecondsSinceEpoch(raw);
|
|
return DateTime.fromMillisecondsSinceEpoch(raw * 1000);
|
|
}
|
|
return DateTime.tryParse(value.toString());
|
|
}
|
|
}
|