126 lines
3.6 KiB
Dart
126 lines
3.6 KiB
Dart
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../data/runs_repository.dart';
|
|
import 'action_refusal.dart';
|
|
import 'cancel_dialog.dart';
|
|
import 'cancel_eligibility.dart';
|
|
import 'cancel_wording.dart';
|
|
|
|
/// The run detail's deliberate cancel entry point.
|
|
///
|
|
/// Renders one native button only while [run] is cancellable under the browser
|
|
/// client's rule. Opening the prompt or choosing [cancelKeepLabel] sends
|
|
/// nothing; only the confirm action asks the server to stop the run. A refusal
|
|
/// is returned to the kept-open prompt immediately and the run is re-read
|
|
/// separately, so [onRunChanged] still receives server truth without locking
|
|
/// the prompt while that read is pending.
|
|
class CancelRunAction extends StatefulWidget {
|
|
const CancelRunAction({
|
|
super.key,
|
|
required this.run,
|
|
required this.gateway,
|
|
required this.onRunChanged,
|
|
});
|
|
|
|
final JsonMap run;
|
|
final ApiGateway gateway;
|
|
final ValueChanged<JsonMap> onRunChanged;
|
|
|
|
@override
|
|
State<CancelRunAction> createState() => _CancelRunActionState();
|
|
}
|
|
|
|
class _CancelRunActionState extends State<CancelRunAction> {
|
|
bool _dialogOpen = false;
|
|
Future<bool?>? _resync;
|
|
|
|
bool _usesCupertino(BuildContext context) {
|
|
final material = Localizations.of<MaterialLocalizations>(
|
|
context,
|
|
MaterialLocalizations,
|
|
);
|
|
return material == null;
|
|
}
|
|
|
|
Future<void> _open() async {
|
|
final id = cancelRunId(widget.run);
|
|
if (id == null || !canCancelRun(widget.run) || _dialogOpen) return;
|
|
_dialogOpen = true;
|
|
try {
|
|
await showCancelRunPrompt(
|
|
context: context,
|
|
runId: id,
|
|
cupertino: _usesCupertino(context),
|
|
onSubmit: () => _submit(id),
|
|
);
|
|
} finally {
|
|
_dialogOpen = false;
|
|
if (mounted) setState(() {});
|
|
}
|
|
}
|
|
|
|
Future<ActionRefusal?> _submit(num id) async {
|
|
final repository = RunsRepository(widget.gateway);
|
|
try {
|
|
final run = await repository.cancelRun(id);
|
|
if (!mounted) return null;
|
|
if (_owns(id)) widget.onRunChanged(run);
|
|
return null;
|
|
} catch (error) {
|
|
return ActionRefusal(
|
|
describeCancelError(error),
|
|
stillPossible: _resyncRun(id),
|
|
);
|
|
}
|
|
}
|
|
|
|
bool _owns(num id) => mounted && cancelRunId(widget.run) == id;
|
|
|
|
/// One bounded re-read per refusal. A refusal that arrives while a read is
|
|
/// already in flight observes that same read instead of starting another.
|
|
Future<bool?> _resyncRun(num id) {
|
|
return _resync ??= _readRun(id);
|
|
}
|
|
|
|
Future<bool?> _readRun(num id) async {
|
|
try {
|
|
final run = await RunsRepository(widget.gateway).getRun(id);
|
|
if (!_owns(id)) return null;
|
|
widget.onRunChanged(run);
|
|
return canCancelRun(run);
|
|
} catch (_) {
|
|
// Unknown server truth: keep the refusal and leave a deliberate retry.
|
|
return null;
|
|
} finally {
|
|
_resync = null;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
if (cancelRunId(widget.run) == null || !canCancelRun(widget.run)) {
|
|
return const SizedBox.shrink();
|
|
}
|
|
if (_usesCupertino(context)) {
|
|
// The web tints Cancel as the one destructive run action.
|
|
return CupertinoButton.tinted(
|
|
sizeStyle: CupertinoButtonSize.small,
|
|
key: cancelActionKey,
|
|
color: CupertinoColors.systemRed,
|
|
onPressed: _open,
|
|
child: const Text(cancelActionLabel),
|
|
);
|
|
}
|
|
return OutlinedButton(
|
|
key: cancelActionKey,
|
|
style: OutlinedButton.styleFrom(
|
|
foregroundColor: Theme.of(context).colorScheme.error,
|
|
),
|
|
onPressed: _open,
|
|
child: const Text(cancelActionLabel),
|
|
);
|
|
}
|
|
}
|