Upload files into the shown folder from the chat Files panel

The header gains an Upload button that uses the host file picker (disabled
with its reason where no picker exists), and the panel body becomes a drop
target: on web, document drag events are observed through a dart:js_interop
seam and a file drag over the panel shows a highlight naming the folder.
Each file is posted to POST /files?path=<folder> through an injectable
transport; refusals (exists, sign in, too large) stay visible until dismissed
and the folder reloads afterwards. The list/grid builders move to
files_entries.dart to keep the panel small.
This commit is contained in:
2026-11-09 00:09:01 +00:00
parent c600f1560c
commit b8fb4d350c
12 changed files with 1190 additions and 98 deletions
@@ -1,7 +1,10 @@
import 'package:flutter/foundation.dart';
import '../../../core/api_gateway.dart';
import '../../../core/transport/pipelines_client.dart';
import '../data/directory_listing.dart';
import '../domain/chat_attachment_picker.dart';
import 'files_models.dart';
import 'files_upload.dart';
class FilesController extends ChangeNotifier {
FilesController({required this.gateway, required this.initialPath});
@@ -18,7 +21,17 @@ class FilesController extends ChangeNotifier {
int _request = 0;
bool _disposed = false;
/// Files still being stored and the size of the batch they belong to.
int uploading = 0;
int uploadTotal = 0;
/// Why the last upload batch failed, until dismissed or a new batch starts.
String? uploadError;
bool get missingDirectory => initialPath.trim().isEmpty;
String get uploadLabel => uploadTotal <= 1
? 'Uploading…'
: 'Uploading ${uploadTotal - uploading + 1} of $uploadTotal…';
List<DirectoryEntry> get entries {
final current = listing;
if (current == null) return const [];
@@ -75,6 +88,54 @@ class FilesController extends ChangeNotifier {
}
Future<void> retry() => open(listing?.path ?? initialPath);
/// Stores [files] in the shown folder, one request each, then reloads that
/// folder so the new entries appear. Each refusal is kept in [uploadError]
/// in the server's words; the remaining files are still attempted.
Future<void> upload(List<ChatPickedFile> files) async {
final directory = listing?.path;
if (files.isEmpty) return;
if (directory == null) {
reportUploadError('Open a folder before uploading files.');
return;
}
final endpoint = configuredGatewayEndpoint(gateway);
uploadTotal += files.length;
uploading += files.length;
uploadError = null;
_notify();
final failures = <String>[];
for (final file in files) {
try {
await uploadFileInto(endpoint, directory, file);
} on FilesUploadException catch (error) {
failures.add(error.message);
} finally {
uploading -= 1;
}
if (_disposed) return;
_notify();
}
if (uploading == 0) uploadTotal = 0;
if (failures.isNotEmpty) uploadError = failures.join('\n');
_notify();
// The operator may have moved on while the batch was in flight; only the
// folder that received the files is reloaded.
if (listing?.path == directory) await retry();
}
/// Shows a host-side upload failure (no picker, unreadable drop) in the
/// same place as a server refusal.
void reportUploadError(String message) {
uploadError = message;
_notify();
}
void dismissUploadError() {
uploadError = null;
_notify();
}
void toggleHidden(bool value) {
showHidden = value;
_notify();
@@ -0,0 +1,79 @@
import 'dart:ui' show Offset;
import '../domain/chat_attachment_picker.dart';
import 'files_drop_stub.dart'
if (dart.library.js_interop) 'files_drop_web.dart'
as impl;
/// Stops observing the host's drag events for one drop area.
typedef FilesDropUnsubscribe = void Function();
/// Registers [listener] with the host and returns its cancellation.
typedef FilesDropSubscribe =
FilesDropUnsubscribe Function(FilesDropListener listener);
/// One drop area's view of a host drag that carries files.
///
/// Positions are logical pixels in the Flutter view's coordinate space, so a
/// listener compares them with its own render box. The host asks [accepts]
/// before it takes over the drag; a drag the area does not accept keeps the
/// host's default behaviour.
class FilesDropListener {
const FilesDropListener({
required this.accepts,
required this.onHover,
required this.onLeave,
required this.onDrop,
required this.onError,
});
/// Whether a drop at [position] would land on this area right now.
final bool Function(Offset position) accepts;
/// A file drag is over the area at [position].
final void Function(Offset position) onHover;
/// The drag left the area, ended or was dropped.
final void Function() onLeave;
/// Files were dropped on the area, in the host's order.
final void Function(List<ChatPickedFile> files) onDrop;
/// One dropped item whose bytes could not be read (a folder, for example).
final void Function(Object error) onError;
}
/// The file drag-and-drop seam for one host.
///
/// The web host observes the browser's own drag events on the document and
/// reads dropped files before reporting them as [ChatPickedFile] rows. A host
/// without file drops constructs [FilesDrop.unsupported] so the panel offers
/// the Upload button alone instead of pretending to listen. Tests inject a
/// fake [subscribe] and drive the listener directly.
class FilesDrop {
const FilesDrop({required FilesDropSubscribe this.subscribe})
: unsupportedMessage = null;
const FilesDrop.unsupported(String message)
: subscribe = null,
unsupportedMessage = message;
/// The host's drag listener registration, or null when unsupported.
final FilesDropSubscribe? subscribe;
/// Why this host cannot observe file drops, when [subscribe] is null.
final String? unsupportedMessage;
bool get isSupported => subscribe != null;
/// Starts observing the host's drag events. A host without the capability
/// throws [UnsupportedError] with [unsupportedMessage].
FilesDropUnsubscribe listen(FilesDropListener listener) {
final subscribe = this.subscribe;
if (subscribe == null) throw UnsupportedError(unsupportedMessage!);
return subscribe(listener);
}
}
/// The drop seam for the running host.
FilesDrop get hostFilesDrop => impl.hostFilesDrop;
@@ -0,0 +1,111 @@
import 'package:flutter/material.dart';
import '../domain/chat_attachment_picker.dart';
import 'files_drop.dart';
/// Makes [child] a drop target for host file drags: while a file drag is over
/// it, a highlight names the folder the files would land in, and a drop hands
/// the files to [onFiles]. Nothing is drawn when the host has no drop support
/// or [folderLabel] is null (no folder is open yet).
class FilesDropArea extends StatefulWidget {
const FilesDropArea({
super.key,
required this.drop,
required this.folderLabel,
required this.onFiles,
required this.onError,
required this.child,
});
final FilesDrop drop;
/// The shown folder's label, or null while there is no folder to drop into.
final String? folderLabel;
final ValueChanged<List<ChatPickedFile>> onFiles;
final ValueChanged<Object> onError;
final Widget child;
@override
State<FilesDropArea> createState() => _FilesDropAreaState();
}
class _FilesDropAreaState extends State<FilesDropArea> {
FilesDropUnsubscribe? _unsubscribe;
bool _hovering = false;
@override
void initState() {
super.initState();
if (widget.drop.isSupported) {
_unsubscribe = widget.drop.listen(
FilesDropListener(
accepts: _accepts,
onHover: (_) => _setHovering(true),
onLeave: () => _setHovering(false),
onDrop: _dropped,
onError: (error) {
if (mounted) widget.onError(error);
},
),
);
}
}
@override
void dispose() {
_unsubscribe?.call();
super.dispose();
}
bool _accepts(Offset position) {
if (!mounted || widget.folderLabel == null) return false;
final box = context.findRenderObject();
if (box is! RenderBox || !box.hasSize) return false;
return box.paintBounds.contains(box.globalToLocal(position));
}
void _setHovering(bool value) {
if (!mounted || _hovering == value) return;
setState(() => _hovering = value);
}
void _dropped(List<ChatPickedFile> files) {
_setHovering(false);
if (mounted && files.isNotEmpty) widget.onFiles(files);
}
@override
Widget build(BuildContext context) {
final scheme = Theme.of(context).colorScheme;
return Stack(
fit: StackFit.passthrough,
children: [
widget.child,
if (_hovering && widget.folderLabel != null)
Positioned.fill(
child: IgnorePointer(
child: Semantics(
label: 'Drop to upload to ${widget.folderLabel}',
child: DecoratedBox(
decoration: BoxDecoration(
color: scheme.primaryContainer.withValues(alpha: .6),
border: Border.all(color: scheme.primary, width: 2),
),
child: Center(
child: Padding(
padding: const EdgeInsets.all(24),
child: Text(
'Drop to upload to ${widget.folderLabel}',
textAlign: TextAlign.center,
style: Theme.of(context).textTheme.titleMedium,
),
),
),
),
),
),
),
],
);
}
}
@@ -0,0 +1,11 @@
import 'files_drop.dart';
/// Native fallback for file drag-and-drop in the Files panel.
///
/// Only the web host observes drag events in this slice; a native host keeps
/// the Upload button and reports the missing drop capability plainly.
const String filesDropUnsupportedMessage =
'Dropping files is not supported on this platform yet.';
FilesDrop get hostFilesDrop =>
const FilesDrop.unsupported(filesDropUnsupportedMessage);
@@ -0,0 +1,177 @@
import 'dart:async';
import 'dart:js_interop';
import 'dart:ui' show Offset;
import '../domain/chat_attachment_picker.dart';
import 'files_drop.dart';
/// Browser file drops observed at the document for each mounted Files panel.
/// A drag that carries files and sits over an accepting area is taken over
/// (so the browser does not navigate to the dropped file); everything else
/// keeps the browser's default. Uses dart:js_interop so the bridge supports
/// JavaScript and WebAssembly builds.
@JS('document')
external _Document get _document;
extension type _Document._(JSObject _) implements JSObject {
external void addEventListener(
JSString type,
JSFunction listener,
JSBoolean capture,
);
external void removeEventListener(
JSString type,
JSFunction listener,
JSBoolean capture,
);
external _Element? querySelector(JSString selectors);
}
extension type _Element._(JSObject _) implements JSObject {
external _DOMRect getBoundingClientRect();
}
extension type _DOMRect._(JSObject _) implements JSObject {
external double get left;
external double get top;
}
extension type _DragEvent._(JSObject _) implements JSObject {
external double get clientX;
external double get clientY;
external _DataTransfer? get dataTransfer;
external JSObject? get relatedTarget;
external void preventDefault();
}
extension type _DataTransfer._(JSObject _) implements JSObject {
external JSArray<JSString> get types;
external _FileList get files;
external set dropEffect(JSString value);
}
extension type _FileList._(JSObject _) implements JSObject {
external int get length;
external _File? item(int index);
}
extension type _File._(JSObject _) implements JSObject {
external JSString get name;
external JSString get type;
external JSPromise<JSArrayBuffer> arrayBuffer();
}
FilesDrop get hostFilesDrop => const FilesDrop(subscribe: _subscribe);
bool _carriesFiles(_DragEvent event) {
final data = event.dataTransfer;
if (data == null) return false;
for (final type in data.types.toDart) {
if (type.toDart == 'Files') return true;
}
return false;
}
/// The pointer in Flutter view coordinates. The view normally fills the page,
/// so this is the viewport position minus the view's own offset.
Offset _position(_DragEvent event) {
final view = _document.querySelector('flutter-view'.toJS);
if (view == null) return Offset(event.clientX, event.clientY);
final rect = view.getBoundingClientRect();
return Offset(event.clientX - rect.left, event.clientY - rect.top);
}
FilesDropUnsubscribe _subscribe(FilesDropListener listener) {
var hovering = false;
void leave() {
if (!hovering) return;
hovering = false;
listener.onLeave();
}
void handleOver(JSObject raw) {
final event = _DragEvent._(raw);
if (!_carriesFiles(event)) return;
final position = _position(event);
if (!listener.accepts(position)) {
leave();
return;
}
event.preventDefault();
event.dataTransfer!.dropEffect = 'copy'.toJS;
hovering = true;
listener.onHover(position);
}
void handleLeave(JSObject raw) {
// relatedTarget is null when the drag leaves the window; movement between
// page elements keeps reporting through dragover.
if (_DragEvent._(raw).relatedTarget == null) leave();
}
void handleDrop(JSObject raw) {
final event = _DragEvent._(raw);
if (!_carriesFiles(event)) return;
final accepted = listener.accepts(_position(event));
leave();
if (!accepted) return;
event.preventDefault();
final files = event.dataTransfer!.files;
final dropped = <_File>[];
for (var index = 0; index < files.length; index += 1) {
final file = files.item(index);
if (file != null) dropped.add(file);
}
unawaited(_readFiles(dropped, listener));
}
final over = handleOver.toJS;
final left = handleLeave.toJS;
final drop = handleDrop.toJS;
_document.addEventListener('dragenter'.toJS, over, true.toJS);
_document.addEventListener('dragover'.toJS, over, true.toJS);
_document.addEventListener('dragleave'.toJS, left, true.toJS);
_document.addEventListener('drop'.toJS, drop, true.toJS);
return () {
_document.removeEventListener('dragenter'.toJS, over, true.toJS);
_document.removeEventListener('dragover'.toJS, over, true.toJS);
_document.removeEventListener('dragleave'.toJS, left, true.toJS);
_document.removeEventListener('drop'.toJS, drop, true.toJS);
};
}
Future<void> _readFiles(List<_File> files, FilesDropListener listener) async {
final picked = <ChatPickedFile>[];
final failures = <Object>[];
for (final file in files) {
try {
final buffer = await file.arrayBuffer().toDart;
picked.add(
ChatPickedFile(
name: file.name.toDart,
mime: file.type.toDart,
bytes: buffer.toDart.asUint8List(),
),
);
} catch (error) {
// A dropped folder has no readable bytes; it must not hide the files.
failures.add(error);
}
}
if (picked.isNotEmpty) listener.onDrop(picked);
for (final failure in failures) {
listener.onError(failure);
}
}
@@ -0,0 +1,91 @@
import 'package:flutter/material.dart';
import '../data/directory_listing.dart';
import 'files_icons.dart';
import 'files_models.dart';
import 'files_thumbnail.dart';
/// The folder's entries as the list or the thumbnail grid. Tapping opens a
/// folder or a file through [onTap]; [menu] supplies a file's action menu.
class FilesEntries extends StatelessWidget {
const FilesEntries({
super.key,
required this.entries,
required this.view,
required this.endpoint,
required this.onTap,
required this.menu,
});
final List<DirectoryEntry> entries;
final FilesViewMode view;
final String endpoint;
final ValueChanged<DirectoryEntry> onTap;
final Widget Function(DirectoryEntry entry) menu;
@override
Widget build(BuildContext context) =>
view == FilesViewMode.grid ? _grid() : _list();
Widget _list() => ListView.builder(
itemCount: entries.length,
itemBuilder: (_, index) {
final entry = entries[index];
return ListTile(
onTap: () => onTap(entry),
leading: Icon(fileIcon(entry)),
title: Text(entry.name, maxLines: 2, overflow: TextOverflow.ellipsis),
subtitle: Text(
entry.isDir
? 'Folder'
: '${fileModifiedLabel(entry.modified)} · ${fileSizeLabel(entry.size)}',
),
trailing: entry.isDir
? null
: Row(
mainAxisSize: MainAxisSize.min,
children: [Text(fileKind(entry)), menu(entry)],
),
);
},
);
Widget _grid() => GridView.builder(
padding: const EdgeInsets.all(12),
gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent(
maxCrossAxisExtent: 180,
childAspectRatio: .85,
),
itemCount: entries.length,
itemBuilder: (_, index) {
final entry = entries[index];
return InkWell(
onTap: () => onTap(entry),
child: Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
children: [
Align(
alignment: Alignment.centerRight,
child: entry.isDir ? const SizedBox(height: 48) : menu(entry),
),
Expanded(
child: Center(
child: FileThumbnail(entry: entry, endpoint: endpoint),
),
),
const SizedBox(height: 8),
Text(
entry.name,
maxLines: 2,
overflow: TextOverflow.ellipsis,
textAlign: TextAlign.center,
),
],
),
),
),
);
},
);
}
@@ -2,6 +2,7 @@ import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../ui/layout/app_overflow_menu.dart';
import '../data/directory_listing.dart';
import '../domain/chat_attachment_picker.dart';
import '../ui/sessions/chat_adaptive.dart';
import 'files_controller.dart';
import 'files_models.dart';
@@ -11,9 +12,23 @@ class FilesHeader extends StatelessWidget {
super.key,
required this.controller,
required this.filter,
required this.picker,
required this.onUpload,
});
final FilesController controller;
final TextEditingController filter;
/// The host's file picker; an unsupported host disables Upload with its
/// reason in the tooltip.
final ChatAttachmentPicker picker;
final VoidCallback onUpload;
bool get _canUpload =>
picker.isSupported &&
controller.listing != null &&
!controller.loading &&
controller.uploading == 0;
@override
Widget build(BuildContext context) {
final listing = controller.listing;
@@ -40,6 +55,13 @@ class FilesHeader extends StatelessWidget {
overflow: TextOverflow.ellipsis,
),
),
IconButton(
tooltip: picker.isSupported
? 'Upload files'
: 'Upload files: ${picker.unsupportedMessage}',
onPressed: _canUpload ? onUpload : null,
icon: const Icon(Icons.upload_file),
),
IconButton(
tooltip: 'Refresh',
onPressed: controller.loading ? null : controller.retry,
+80 -98
View File
@@ -3,11 +3,13 @@ import 'package:flutter/cupertino.dart';
import '../../../ui/adaptive/host.dart';
import '../../../core/transport/pipelines_client.dart';
import '../data/directory_listing.dart';
import '../domain/chat_attachment_picker.dart';
import '../ui/sessions/chat_adaptive.dart';
import 'files_controller.dart';
import 'files_icons.dart';
import 'files_models.dart';
import 'files_thumbnail.dart';
import 'files_drop.dart';
import 'files_drop_area.dart';
import 'files_entries.dart';
import 'files_upload_notice.dart';
import 'files_viewer.dart';
import 'files_header.dart';
import '../../../ui/layout/app_overflow_menu.dart';
@@ -28,20 +30,43 @@ class FilesPanel extends StatefulWidget {
required this.controller,
this.onOpen,
this.viewer = const FilesViewer(),
this.picker,
this.drop,
});
final FilesController controller;
final ValueChanged<DirectoryEntry>? onOpen;
/// Opens and downloads files; tests inject one that never fetches.
final FilesViewer viewer;
/// The Upload button's file picker and the host drag-and-drop seam; null
/// means the running host's. Tests inject fakes.
final ChatAttachmentPicker? picker;
final FilesDrop? drop;
@override
State<FilesPanel> createState() => _FilesPanelState();
}
class _FilesPanelState extends State<FilesPanel> {
late final TextEditingController _filter = TextEditingController();
late final ChatAttachmentPicker _picker =
widget.picker ?? hostChatAttachmentPicker;
late final FilesDrop _drop = widget.drop ?? hostFilesDrop;
FilesController get controller => widget.controller;
String get _endpoint => configuredGatewayEndpoint(controller.gateway);
Future<void> _pickAndUpload() async {
final List<ChatPickedFile>? files;
try {
files = await _picker.pick();
} catch (error) {
controller.reportUploadError('$error');
return;
}
if (files == null || files.isEmpty) return;
await controller.upload(files);
}
@override
void initState() {
super.initState();
@@ -80,109 +105,66 @@ class _FilesPanelState extends State<FilesPanel> {
child: Builder(
builder: (context) => Material(
color: Theme.of(context).colorScheme.surface,
child: Column(
children: [
FilesHeader(controller: controller, filter: _filter),
if (controller.error != null)
ChatErrorNotice(
message: controller.error!,
onRetry: controller.retry,
child: FilesDropArea(
drop: _drop,
folderLabel: listing == null
? null
: homeRelativeLabel(listing.home, listing.path),
onFiles: controller.upload,
onError: (error) => controller.reportUploadError(
'A dropped item could not be read: $error',
),
child: Column(
children: [
FilesHeader(
controller: controller,
filter: _filter,
picker: _picker,
onUpload: _pickAndUpload,
),
if (controller.loading && listing == null)
const Expanded(child: ChatLoadingIndicator())
else if (listing != null &&
entries.isEmpty &&
!controller.loading)
Expanded(
child: _FilesMessage(
controller.filter.isEmpty
? 'This folder is empty.'
: 'No files match your filter.',
if (controller.error != null)
ChatErrorNotice(
message: controller.error!,
onRetry: controller.retry,
),
)
else
Expanded(
child: controller.view == FilesViewMode.grid
? _grid(entries)
: _list(entries),
),
if (listing?.truncated == true)
const Padding(
padding: EdgeInsets.all(8),
child: Text('Some entries are not shown.'),
),
],
FilesUploadNotice(controller: controller),
if (controller.loading && listing == null)
const Expanded(child: ChatLoadingIndicator())
else if (listing != null &&
entries.isEmpty &&
!controller.loading)
Expanded(
child: _FilesMessage(
controller.filter.isEmpty
? 'This folder is empty.'
: 'No files match your filter.',
),
)
else
Expanded(
child: FilesEntries(
entries: entries,
view: controller.view,
endpoint: _endpoint,
onTap: (entry) => entry.isDir
? controller.open(entry.path)
: _open(entry),
menu: _menu,
),
),
if (listing?.truncated == true)
const Padding(
padding: EdgeInsets.all(8),
child: Text('Some entries are not shown.'),
),
],
),
),
),
),
);
}
Widget _list(List<DirectoryEntry> entries) => ListView.builder(
itemCount: entries.length,
itemBuilder: (_, index) {
final entry = entries[index];
return ListTile(
onTap: () => entry.isDir ? controller.open(entry.path) : _open(entry),
leading: Icon(fileIcon(entry)),
title: Text(entry.name, maxLines: 2, overflow: TextOverflow.ellipsis),
subtitle: Text(
entry.isDir
? 'Folder'
: '${fileModifiedLabel(entry.modified)} · ${fileSizeLabel(entry.size)}',
),
trailing: entry.isDir
? null
: Row(
mainAxisSize: MainAxisSize.min,
children: [Text(fileKind(entry)), _menu(entry)],
),
);
},
);
Widget _grid(List<DirectoryEntry> entries) => GridView.builder(
padding: const EdgeInsets.all(12),
gridDelegate: const SliverGridDelegateWithMaxCrossAxisExtent(
maxCrossAxisExtent: 180,
childAspectRatio: .85,
),
itemCount: entries.length,
itemBuilder: (_, index) {
final entry = entries[index];
return InkWell(
onTap: () => entry.isDir ? controller.open(entry.path) : _open(entry),
child: Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
children: [
Align(
alignment: Alignment.centerRight,
child: entry.isDir
? const SizedBox(height: 48)
: _menu(entry),
),
Expanded(
child: Center(
child: FileThumbnail(entry: entry, endpoint: _endpoint),
),
),
const SizedBox(height: 8),
Text(
entry.name,
maxLines: 2,
overflow: TextOverflow.ellipsis,
textAlign: TextAlign.center,
),
],
),
),
),
);
},
);
/// Open and Download for one file; a folder has no menu (nothing to save).
Widget _menu(DirectoryEntry entry) => AppOverflowMenu<FileAction>(
label: 'File actions',
@@ -0,0 +1,99 @@
import 'dart:convert';
import 'dart:typed_data';
import '../../../core/transport/server_url.dart';
import '../data/upload/chat_upload.dart';
import '../domain/chat_attachment_picker.dart';
/// Posts one file's bytes to a `POST /files?path=<folder>` URL.
typedef FilesUploadPost =
Future<ChatUploadReply> Function(
Uri uri, {
required String name,
required String mime,
required Uint8List bytes,
});
/// The transport the Files panel uploads with.
///
/// Production keeps [postChatUpload] (raw body, name header, session cookie).
/// Widget tests swap in a recorder so no socket is opened. Restore it after a
/// test.
FilesUploadPost postFileUpload = postChatUpload;
/// Why one file could not be stored, in words the panel shows as they are.
class FilesUploadException implements Exception {
const FilesUploadException(this.message);
final String message;
@override
String toString() => message;
}
/// Uploads [file] into [directory] on the server behind [endpoint] and returns
/// the stored path the server reports. Every failure is a
/// [FilesUploadException]; nothing is retried or renamed on the caller's
/// behalf, so an existing file is reported rather than replaced.
Future<String> uploadFileInto(
String endpoint,
String directory,
ChatPickedFile file,
) async {
final name = file.name.trim();
if (name.isEmpty) {
throw const FilesUploadException(
'A file without a name cannot be uploaded.',
);
}
final Uri uri;
try {
uri = ServerUrl.resourceUri(
endpoint,
'/files',
query: <String, String>{'path': directory},
);
} on FormatException {
throw const FilesUploadException(
'No server is configured to upload files to.',
);
}
final ChatUploadReply reply;
try {
reply = await postFileUpload(
uri,
name: name,
mime: file.mime.trim().isEmpty ? 'application/octet-stream' : file.mime,
bytes: file.bytes,
);
} catch (error) {
throw FilesUploadException('"$name" could not be uploaded: $error');
}
final reason = reply.body.trim();
switch (reply.status) {
case 200:
break;
case 401:
throw const FilesUploadException(
'Sign in to upload files (Settings → Sign in).',
);
case 409:
throw FilesUploadException('"$name" already exists in this folder.');
case 413:
throw FilesUploadException(
'"$name" is too large to upload (100 MiB limit).',
);
default:
throw FilesUploadException(
reason.isEmpty
? '"$name" could not be uploaded (HTTP ${reply.status}).'
: '"$name" could not be uploaded: $reason',
);
}
try {
final decoded = jsonDecode(reply.body);
final path = decoded is Map ? decoded['path'] : null;
if (path is String && path.isNotEmpty) return path;
} on FormatException {
// Reported below.
}
throw FilesUploadException('"$name" upload returned no stored path.');
}
@@ -0,0 +1,60 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../ui/sessions/chat_adaptive.dart';
import 'files_controller.dart';
/// The Files panel's upload feedback: a progress strip while files are being
/// stored and the server's refusal (exists, sign in, too large) until the
/// operator dismisses it. Upload failures are separate from the folder error,
/// whose Retry reloads the listing.
class FilesUploadNotice extends StatelessWidget {
const FilesUploadNotice({super.key, required this.controller});
final FilesController controller;
@override
Widget build(BuildContext context) {
final error = controller.uploadError;
final cupertino =
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
return Column(
children: [
if (controller.uploading > 0)
Semantics(
label: controller.uploadLabel,
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 4),
child: Row(
children: [
Expanded(
child: cupertino
? const CupertinoActivityIndicator()
: const LinearProgressIndicator(),
),
const SizedBox(width: 12),
Text(controller.uploadLabel),
],
),
),
),
if (error != null)
cupertino
? ChatCupertinoMessage(
message: error,
icon: CupertinoIcons.exclamationmark_circle,
actionLabel: 'Dismiss',
onAction: controller.dismissUploadError,
)
: MaterialBanner(
content: Text(error),
actions: [
TextButton(
onPressed: controller.dismissUploadError,
child: const Text('Dismiss'),
),
],
),
],
);
}
}
@@ -0,0 +1,261 @@
import 'dart:async';
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/core/transport/pipelines_client.dart';
import 'package:pipelines_app/features/chat/domain/chat_attachment_picker.dart';
import 'package:pipelines_app/features/chat/files/files_controller.dart';
import 'package:pipelines_app/features/chat/files/files_drop.dart';
import 'package:pipelines_app/features/chat/files/files_panel.dart';
import 'package:pipelines_app/features/chat/files/files_upload.dart';
import 'package:pipelines_app/features/chat/files/files_urls.dart';
import 'package:pipelines_app/features/chat/files/files_viewer.dart';
/// Lists `/home/demo` and counts the listings so a refresh after an upload is
/// observable.
class Gateway extends PipelinesClient {
@override
Uri get endpoint => Uri.parse('ws://example.test/connect');
int listings = 0;
@override
Stream<JsonMap> get frames => const Stream.empty();
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
listings += 1;
return {
'directory_listing': {
'path': '/home/demo',
'home': '/home',
'entries': [
{'name': 'notes.txt', 'path': '/home/demo/notes.txt', 'size': 12},
],
},
};
}
}
/// One recorded `POST /files`.
typedef Posted = ({Uri uri, String name, String mime, int size});
ChatPickedFile picked(String name, [String mime = 'text/plain']) =>
ChatPickedFile(name: name, mime: mime, bytes: Uint8List.fromList([1, 2]));
void main() {
late FileUrlResolver originalUrls;
late FilesUploadPost originalPost;
final posted = <Posted>[];
var reply = (status: 200, body: '{"path":"/home/demo/new.txt"}');
Completer<void>? gate;
setUp(() {
originalUrls = resolveFileUrls;
originalPost = postFileUpload;
resolveFileUrls = (_, path) => fileUrls('ws://example.test/connect', path);
posted.clear();
reply = (status: 200, body: '{"path":"/home/demo/new.txt"}');
gate = null;
postFileUpload =
(uri, {required name, required mime, required bytes}) async {
posted.add((uri: uri, name: name, mime: mime, size: bytes.length));
if (gate != null) await gate!.future;
return reply;
};
});
tearDown(() {
resolveFileUrls = originalUrls;
postFileUpload = originalPost;
});
Future<({FilesController controller, Gateway gateway})> pump(
WidgetTester tester, {
ChatAttachmentPicker? picker,
FilesDrop? drop,
}) async {
final gateway = Gateway();
final controller = FilesController(
gateway: gateway,
initialPath: '/home/demo',
);
addTearDown(controller.dispose);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: FilesPanel(
controller: controller,
viewer: const FilesViewer(),
picker:
picker ??
ChatAttachmentPicker(select: () async => [picked('new.txt')]),
drop: drop ?? const FilesDrop.unsupported('no drops in tests'),
),
),
),
);
await tester.pumpAndSettle();
return (controller: controller, gateway: gateway);
}
testWidgets('Upload button picks files, posts them to the shown folder and '
'refreshes', (tester) async {
gate = Completer<void>();
final mounted = await pump(tester);
expect(mounted.gateway.listings, 1);
await tester.tap(find.byTooltip('Upload files'));
await tester.pump();
expect(find.text('Uploading…'), findsOneWidget);
expect(find.byType(LinearProgressIndicator), findsOneWidget);
expect(
tester
.widget<IconButton>(
find.ancestor(
of: find.byIcon(Icons.upload_file),
matching: find.byType(IconButton),
),
)
.onPressed,
isNull,
reason: 'a second batch waits for the first',
);
gate!.complete();
await tester.pumpAndSettle();
expect(posted, hasLength(1));
expect(posted.single.uri.path, '/files');
expect(posted.single.uri.queryParameters['path'], '/home/demo');
expect(posted.single.name, 'new.txt');
expect(posted.single.mime, 'text/plain');
expect(posted.single.size, 2);
expect(mounted.gateway.listings, 2, reason: 'the folder is reloaded');
expect(find.text('Uploading…'), findsNothing);
expect(mounted.controller.uploadError, isNull);
});
testWidgets('a cancelled picker uploads nothing', (tester) async {
final mounted = await pump(
tester,
picker: ChatAttachmentPicker(select: () async => null),
);
await tester.tap(find.byTooltip('Upload files'));
await tester.pumpAndSettle();
expect(posted, isEmpty);
expect(mounted.gateway.listings, 1);
});
testWidgets('an unsupported picker disables Upload with its reason', (
tester,
) async {
await pump(
tester,
picker: const ChatAttachmentPicker.unsupported('No picker here.'),
);
final button = tester.widget<IconButton>(
find.ancestor(
of: find.byIcon(Icons.upload_file),
matching: find.byType(IconButton),
),
);
expect(button.onPressed, isNull);
expect(find.byTooltip('Upload files: No picker here.'), findsOneWidget);
});
testWidgets('server refusals are shown until dismissed', (tester) async {
final mounted = await pump(tester);
for (final (status, body, message) in [
(409, 'exists', '"new.txt" already exists in this folder.'),
(
401,
'Sign in required',
'Sign in to upload files (Settings → Sign in).',
),
(413, 'too big', '"new.txt" is too large to upload (100 MiB limit).'),
]) {
reply = (status: status, body: body);
await tester.tap(find.byTooltip('Upload files'));
await tester.pumpAndSettle();
expect(find.byType(MaterialBanner), findsOneWidget);
expect(find.text(message), findsOneWidget);
expect(mounted.controller.uploadError, message);
await tester.tap(find.text('Dismiss'));
await tester.pumpAndSettle();
expect(find.byType(MaterialBanner), findsNothing);
}
expect(posted, hasLength(3));
});
testWidgets('a batch keeps going after one refusal and lists both', (
tester,
) async {
var calls = 0;
postFileUpload =
(uri, {required name, required mime, required bytes}) async {
calls += 1;
return name == 'kept.txt'
? (status: 409, body: 'exists')
: (status: 200, body: '{"path":"/home/demo/$name"}');
};
final mounted = await pump(
tester,
picker: ChatAttachmentPicker(
select: () async => [picked('kept.txt'), picked('other.txt')],
),
);
await tester.tap(find.byTooltip('Upload files'));
await tester.pumpAndSettle();
expect(calls, 2);
expect(
find.text('"kept.txt" already exists in this folder.'),
findsOneWidget,
);
expect(mounted.gateway.listings, 2);
});
testWidgets('a file drag over the panel highlights the folder and a drop '
'uploads there', (tester) async {
FilesDropListener? listener;
var unsubscribed = 0;
final drop = FilesDrop(
subscribe: (registered) {
listener = registered;
return () => unsubscribed += 1;
},
);
final mounted = await pump(tester, drop: drop);
expect(listener, isNotNull);
final inside = tester.getCenter(find.byType(FilesPanel));
expect(listener!.accepts(inside), isTrue);
expect(listener!.accepts(const Offset(-5, -5)), isFalse);
expect(find.text('Drop to upload to ~/demo'), findsNothing);
listener!.onHover(inside);
await tester.pump();
expect(find.text('Drop to upload to ~/demo'), findsOneWidget);
listener!.onLeave();
await tester.pump();
expect(find.text('Drop to upload to ~/demo'), findsNothing);
listener!.onHover(inside);
await tester.pump();
listener!.onDrop([picked('dropped.png', 'image/png')]);
await tester.pumpAndSettle();
expect(find.text('Drop to upload to ~/demo'), findsNothing);
expect(posted, hasLength(1));
expect(posted.single.name, 'dropped.png');
expect(posted.single.mime, 'image/png');
expect(posted.single.uri.queryParameters['path'], '/home/demo');
expect(mounted.gateway.listings, 2);
listener!.onError(StateError('is a directory'));
await tester.pump();
expect(
find.textContaining('A dropped item could not be read'),
findsOneWidget,
);
await tester.pumpWidget(const SizedBox());
expect(unsubscribed, 1);
});
testWidgets('an unsupported drop host keeps the panel and the button', (
tester,
) async {
await pump(tester, drop: const FilesDrop.unsupported('no drops'));
expect(find.text('notes.txt'), findsOneWidget);
expect(find.byTooltip('Upload files'), findsOneWidget);
});
}
@@ -0,0 +1,138 @@
import 'dart:typed_data';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/domain/chat_attachment_picker.dart';
import 'package:pipelines_app/features/chat/files/files_upload.dart';
void main() {
late FilesUploadPost original;
setUp(() => original = postFileUpload);
tearDown(() => postFileUpload = original);
final file = ChatPickedFile(
name: 'notes.txt',
mime: 'text/plain',
bytes: Uint8List.fromList([1, 2, 3]),
);
test(
'posts to /files with the shown folder and returns the stored path',
() async {
Uri? posted;
String? postedName;
String? postedMime;
postFileUpload =
(uri, {required name, required mime, required bytes}) async {
posted = uri;
postedName = name;
postedMime = mime;
return (
status: 200,
body:
'{"name":"notes.txt","path":"/home/demo/notes.txt","size":3}',
);
};
final path = await uploadFileInto(
'ws://example.test/connect',
'/home/demo',
file,
);
expect(path, '/home/demo/notes.txt');
expect(posted?.path, '/files');
expect(posted?.queryParameters, {'path': '/home/demo'});
expect(posted?.scheme, 'http');
expect(postedName, 'notes.txt');
expect(postedMime, 'text/plain');
},
);
test('a relay endpoint posts through its peer prefix', () async {
Uri? posted;
postFileUpload =
(uri, {required name, required mime, required bytes}) async {
posted = uri;
return (status: 200, body: '{"path":"/home/x/notes.txt"}');
};
await uploadFileInto(
'wss://web.test/peers/laptop/connect',
'/home/x',
file,
);
expect(posted?.path, '/peers/laptop/files');
});
test('server refusals become plain messages', () async {
Future<String> message(int status, String body) async {
postFileUpload =
(uri, {required name, required mime, required bytes}) async =>
(status: status, body: body);
try {
await uploadFileInto('ws://example.test/connect', '/home/demo', file);
} on FilesUploadException catch (error) {
return error.message;
}
return 'no error';
}
expect(
await message(409, 'a file named notes.txt already exists'),
'"notes.txt" already exists in this folder.',
);
expect(
await message(401, 'Sign in required'),
'Sign in to upload files (Settings → Sign in).',
);
expect(
await message(413, 'file exceeds the 100 MiB limit'),
'"notes.txt" is too large to upload (100 MiB limit).',
);
expect(
await message(403, 'folder access denied'),
'"notes.txt" could not be uploaded: folder access denied',
);
expect(
await message(500, ''),
'"notes.txt" could not be uploaded (HTTP 500).',
);
expect(
await message(200, 'not json'),
'"notes.txt" upload returned no stored path.',
);
});
test(
'transport failures and blank names are reported, not swallowed',
() async {
postFileUpload = (uri, {required name, required mime, required bytes}) =>
throw StateError('socket closed');
await expectLater(
uploadFileInto('ws://example.test/connect', '/home/demo', file),
throwsA(
isA<FilesUploadException>().having(
(e) => e.message,
'message',
'"notes.txt" could not be uploaded: Bad state: socket closed',
),
),
);
await expectLater(
uploadFileInto(
'ws://example.test/connect',
'/home/demo',
ChatPickedFile(name: ' ', mime: '', bytes: Uint8List(0)),
),
throwsA(isA<FilesUploadException>()),
);
await expectLater(
uploadFileInto('', '/home/demo', file),
throwsA(
isA<FilesUploadException>().having(
(e) => e.message,
'message',
'No server is configured to upload files to.',
),
),
);
},
);
}