Add torrent acquisition API client

app/lib/acquisition/acquisition_api_client.dart

@@ -0,0 +1,196 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:papyrus/acquisition/acquisition_models.dart';
+import 'package:papyrus/auth/auth_api_client.dart';
+import 'package:papyrus/auth/papyrus_api_config.dart';
+
+class AcquisitionApiClient {
+  final PapyrusApiConfig config;
+  final http.Client _httpClient;
+  final bool _ownsHttpClient;
+
+  AcquisitionApiClient({required this.config, http.Client? httpClient})
+    : _httpClient = httpClient ?? http.Client(),
+      _ownsHttpClient = httpClient == null;
+
+  void close() {
+    if (_ownsHttpClient) {
+      _httpClient.close();
+    }
+  }
+
+  Future<AcquisitionCapabilities> capabilities(String accessToken) async {
+    final response = await _httpClient.get(
+      config.endpoint('/acquisition/capabilities'),
+      headers: _headers(accessToken),
+    );
+    return AcquisitionCapabilities.fromJson(_decodeObject(response));
+  }
+
+  Future<List<AcquisitionEndpoint>> listEndpoints(String accessToken) async {
+    final response = await _httpClient.get(config.endpoint('/acquisition/endpoints'), headers: _headers(accessToken));
+    return _decodeList(response).map(AcquisitionEndpoint.fromJson).toList();
+  }
+
+  Future<AcquisitionEndpoint> createEndpoint({
+    required String accessToken,
+    required String name,
+    required AcquisitionEndpointKind kind,
+    required Uri baseUrl,
+    String? apiKey,
+    String? username,
+    String? password,
+  }) async {
+    final response = await _httpClient.post(
+      config.endpoint('/acquisition/endpoints'),
+      headers: _headers(accessToken),
+      body: jsonEncode({
+        'name': name,
+        'kind': kind.apiValue,
+        'base_url': baseUrl.toString(),
+        'api_key': ?apiKey,
+        'username': ?username,
+        'password': ?password,
+      }),
+    );
+    return AcquisitionEndpoint.fromJson(_decodeObject(response));
+  }
+
+  Future<AcquisitionEndpoint> updateEndpoint({
+    required String accessToken,
+    required String endpointId,
+    String? name,
+    Uri? baseUrl,
+    String? apiKey,
+    String? username,
+    String? password,
+    bool? enabled,
+  }) async {
+    final response = await _httpClient.patch(
+      config.endpoint('/acquisition/endpoints/$endpointId'),
+      headers: _headers(accessToken),
+      body: jsonEncode({
+        'name': ?name,
+        'base_url': ?baseUrl?.toString(),
+        'api_key': ?apiKey,
+        'username': ?username,
+        'password': ?password,
+        'enabled': ?enabled,
+      }),
+    );
+    return AcquisitionEndpoint.fromJson(_decodeObject(response));
+  }
+
+  Future<void> testEndpoint({
+    required String accessToken,
+    String? endpointId,
+    AcquisitionEndpointKind? kind,
+    Uri? baseUrl,
+    String? apiKey,
+    String? username,
+    String? password,
+  }) async {
+    final response = await _httpClient.post(
+      config.endpoint('/acquisition/endpoints/test'),
+      headers: _headers(accessToken),
+      body: jsonEncode({
+        'endpoint_id': ?endpointId,
+        'kind': ?kind?.apiValue,
+        'base_url': ?baseUrl?.toString(),
+        'api_key': ?apiKey,
+        'username': ?username,
+        'password': ?password,
+      }),
+    );
+    final result = _decodeObject(response);
+    if (result['ok'] != true) {
+      throw const AuthApiException(statusCode: 502, message: 'Connection test returned an invalid response');
+    }
+  }
+
+  Future<void> deleteEndpoint({required String accessToken, required String endpointId}) async {
+    final response = await _httpClient.delete(
+      config.endpoint('/acquisition/endpoints/$endpointId'),
+      headers: _headers(accessToken),
+    );
+    if (response.statusCode >= 200 && response.statusCode < 300) return;
+    _decodeObject(response);
+  }
+
+  Future<List<TorrentRelease>> search({
+    required String accessToken,
+    required String query,
+    List<String>? endpointIds,
+  }) async {
+    final response = await _httpClient.post(
+      config.endpoint('/acquisition/search'),
+      headers: _headers(accessToken),
+      body: jsonEncode({'query': query, 'endpoint_ids': ?endpointIds}),
+    );
+    return _decodeList(response).map(TorrentRelease.fromJson).toList();
+  }
+
+  Future<AcquisitionJob> submitRelease({
+    required String accessToken,
+    required String endpointId,
+    required TorrentRelease release,
+    String? category,
+    String? savePath,
+  }) async {
+    final response = await _httpClient.post(
+      config.endpoint('/acquisition/submissions'),
+      headers: _headers(accessToken),
+      body: jsonEncode({
+        'endpoint_id': endpointId,
+        'title': release.title,
+        'download_url': release.downloadUrl,
+        'category': ?category,
+        'save_path': ?savePath,
+      }),
+    );
+    return AcquisitionJob.fromJson(_decodeObject(response));
+  }
+
+  Future<AcquisitionJob> runArrCommand({
+    required String accessToken,
+    required String endpointId,
+    required String command,
+    required List<int> ids,
+  }) async {
+    final response = await _httpClient.post(
+      config.endpoint('/acquisition/arr/$endpointId/commands'),
+      headers: _headers(accessToken),
+      body: jsonEncode({'command': command, 'ids': ids}),
+    );
+    return AcquisitionJob.fromJson(_decodeObject(response));
+  }
+
+  Map<String, String> _headers(String accessToken) => {
+    'Accept': 'application/json',
+    'Content-Type': 'application/json',
+    'Authorization': 'Bearer $accessToken',
+  };
+
+  Map<String, dynamic> _decodeObject(http.Response response) {
+    final decoded = response.body.isEmpty ? <String, dynamic>{} : jsonDecode(response.body) as Map<String, dynamic>;
+    if (response.statusCode >= 200 && response.statusCode < 300) return decoded;
+    final error = decoded['error'];
+    final detail = decoded['detail'];
+    throw AuthApiException(
+      statusCode: response.statusCode,
+      message: error is Map<String, dynamic>
+          ? error['message'] as String? ?? 'Acquisition request failed'
+          : detail is String
+          ? detail
+          : 'Acquisition request failed',
+    );
+  }
+
+  List<Map<String, dynamic>> _decodeList(http.Response response) {
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+      _decodeObject(response);
+    }
+    return (jsonDecode(response.body) as List<dynamic>).cast<Map<String, dynamic>>();
+  }
+}

app/lib/acquisition/acquisition_models.dart

@@ -0,0 +1,174 @@
+enum AcquisitionEndpointKind {
+  qbittorrent,
+  transmission,
+  deluge,
+  prowlarr,
+  torznab,
+  readarr,
+  sonarr,
+  radarr,
+  lidarr,
+  whisparr;
+
+  String get apiValue => name;
+
+  String get label => switch (this) {
+    AcquisitionEndpointKind.qbittorrent => 'qBittorrent',
+    AcquisitionEndpointKind.transmission => 'Transmission',
+    AcquisitionEndpointKind.deluge => 'Deluge',
+    AcquisitionEndpointKind.prowlarr => 'Prowlarr',
+    AcquisitionEndpointKind.torznab => 'Torznab',
+    AcquisitionEndpointKind.readarr => 'Readarr',
+    AcquisitionEndpointKind.sonarr => 'Sonarr',
+    AcquisitionEndpointKind.radarr => 'Radarr',
+    AcquisitionEndpointKind.lidarr => 'Lidarr',
+    AcquisitionEndpointKind.whisparr => 'Whisparr',
+  };
+
+  bool get isDownloadClient => switch (this) {
+    AcquisitionEndpointKind.qbittorrent ||
+    AcquisitionEndpointKind.transmission ||
+    AcquisitionEndpointKind.deluge => true,
+    _ => false,
+  };
+
+  bool get isIndexer => switch (this) {
+    AcquisitionEndpointKind.prowlarr || AcquisitionEndpointKind.torznab => true,
+    _ => false,
+  };
+
+  bool get isArr => switch (this) {
+    AcquisitionEndpointKind.readarr ||
+    AcquisitionEndpointKind.sonarr ||
+    AcquisitionEndpointKind.radarr ||
+    AcquisitionEndpointKind.lidarr ||
+    AcquisitionEndpointKind.whisparr => true,
+    _ => false,
+  };
+}
+
+class AcquisitionCapabilities {
+  final bool enabled;
+  final List<AcquisitionEndpointKind> endpointKinds;
+  final List<AcquisitionEndpointKind> indexerKinds;
+  final List<AcquisitionEndpointKind> downloadClientKinds;
+  final List<AcquisitionEndpointKind> arrKinds;
+  final Map<AcquisitionEndpointKind, List<String>> arrCommands;
+
+  const AcquisitionCapabilities({
+    required this.enabled,
+    required this.endpointKinds,
+    required this.indexerKinds,
+    required this.downloadClientKinds,
+    required this.arrKinds,
+    required this.arrCommands,
+  });
+
+  factory AcquisitionCapabilities.fromJson(Map<String, dynamic> json) {
+    return AcquisitionCapabilities(
+      enabled: json['enabled'] as bool? ?? true,
+      endpointKinds: _kinds(json['endpoint_kinds']),
+      indexerKinds: _kinds(json['indexer_kinds']),
+      downloadClientKinds: _kinds(json['download_client_kinds']),
+      arrKinds: _kinds(json['arr_kinds']),
+      arrCommands: ((json['arr_commands'] as Map<String, dynamic>?) ?? {}).map(
+        (key, value) => MapEntry(AcquisitionEndpointKind.values.byName(key), (value as List<dynamic>).cast<String>()),
+      ),
+    );
+  }
+
+  static List<AcquisitionEndpointKind> _kinds(Object? value) {
+    return ((value as List<dynamic>?) ?? []).cast<String>().map(AcquisitionEndpointKind.values.byName).toList();
+  }
+}
+
+class AcquisitionEndpoint {
+  final String id;
+  final String name;
+  final AcquisitionEndpointKind kind;
+  final Uri baseUrl;
+  final bool enabled;
+
+  const AcquisitionEndpoint({
+    required this.id,
+    required this.name,
+    required this.kind,
+    required this.baseUrl,
+    required this.enabled,
+  });
+
+  factory AcquisitionEndpoint.fromJson(Map<String, dynamic> json) => AcquisitionEndpoint(
+    id: json['endpoint_id'] as String,
+    name: json['name'] as String,
+    kind: AcquisitionEndpointKind.values.byName(json['kind'] as String),
+    baseUrl: Uri.parse(json['base_url'] as String),
+    enabled: json['enabled'] as bool,
+  );
+}
+
+class TorrentRelease {
+  final String title;
+  final String downloadUrl;
+  final String protocol;
+  final String indexer;
+  final int? seeders;
+  final int? sizeBytes;
+
+  const TorrentRelease({
+    required this.title,
+    required this.downloadUrl,
+    required this.protocol,
+    required this.indexer,
+    this.seeders,
+    this.sizeBytes,
+  });
+
+  bool get isMagnet => downloadUrl.startsWith('magnet:');
+
+  factory TorrentRelease.fromJson(Map<String, dynamic> json) => TorrentRelease(
+    title: json['title'] as String,
+    downloadUrl: json['download_url'] as String,
+    protocol: json['protocol'] as String,
+    indexer: json['indexer'] as String,
+    seeders: json['seeders'] as int?,
+    sizeBytes: json['size_bytes'] as int?,
+  );
+}
+
+class AcquisitionJob {
+  final String id;
+  final String? endpointId;
+  final String? ruleId;
+  final String title;
+  final String downloadUrl;
+  final String status;
+  final String? clientReference;
+  final String? error;
+  final DateTime? createdAt;
+
+  const AcquisitionJob({
+    required this.id,
+    required this.endpointId,
+    required this.ruleId,
+    required this.title,
+    required this.downloadUrl,
+    required this.status,
+    required this.clientReference,
+    required this.error,
+    required this.createdAt,
+  });
+
+  bool get isSubmitted => status == 'submitted';
+
+  factory AcquisitionJob.fromJson(Map<String, dynamic> json) => AcquisitionJob(
+    id: json['job_id'] as String,
+    endpointId: json['endpoint_id'] as String?,
+    ruleId: json['rule_id'] as String?,
+    title: json['title'] as String,
+    downloadUrl: json['download_url'] as String,
+    status: json['status'] as String,
+    clientReference: json['client_reference'] as String?,
+    error: json['error'] as String?,
+    createdAt: json['created_at'] == null ? null : DateTime.parse(json['created_at'] as String),
+  );
+}

app/lib/auth/auth_repository.dart

@@ -19,8 +19,6 @@ class AuthRepository {
 
   AuthRepository({required this.apiClient, required this.tokenStore});
 
-  String? get accessToken => tokenStore.accessToken;
-
   bool get _usesDesktopLoopbackOAuth {
     if (kIsWeb) {
       return false;
@@ -223,6 +221,10 @@ class AuthRepository {
     return tokenStore.clear();
   }
 
+  Future<T> withFreshAccessToken<T>(Future<T> Function(String accessToken) action) {
+    return _withFreshAccessToken(action);
+  }
+
   Future<String> _requireAccessToken() async {
     final currentAccessToken = tokenStore.accessToken;