294 lines
10 KiB
Dart
294 lines
10 KiB
Dart
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../core/api_gateway.dart';
|
|
import 'pipeline_models.dart';
|
|
import 'pipeline_repository.dart';
|
|
import 'pipelines_controller.dart';
|
|
import 'pending_run_store.dart';
|
|
import 'widgets/pipeline_controls.dart';
|
|
import 'widgets/pipeline_detail_panel.dart';
|
|
import 'widgets/pipeline_list_panel.dart';
|
|
|
|
export 'pipeline_models.dart' show PipelineDetail, PipelineVersion;
|
|
|
|
/// Below this width the list and detail are separate pages; above it they sit
|
|
/// side by side. One local breakpoint, not a styling system.
|
|
const double kPipelinesWideBreakpoint = 720;
|
|
|
|
/// The read-only Pipelines destination: list, filters/sort, detail, source and
|
|
/// version history.
|
|
///
|
|
/// Standalone use keeps the screen's own native scaffolding. The application
|
|
/// shell sets [embedded] because it already owns the one navigation bar, and
|
|
/// supplies [syncToken] so a reconnect refreshes in place.
|
|
class PipelinesScreen extends StatefulWidget {
|
|
const PipelinesScreen({
|
|
super.key,
|
|
required this.gateway,
|
|
this.endpoint = '',
|
|
this.embedded = false,
|
|
this.syncToken = 0,
|
|
this.onRunStarted,
|
|
this.onViewPipelineRuns,
|
|
this.initialPipelineId,
|
|
this.initialVersion = 0,
|
|
this.initialStageKey,
|
|
});
|
|
|
|
final ApiGateway gateway;
|
|
|
|
/// Validated websocket endpoint used to isolate stored launch intents.
|
|
final String endpoint;
|
|
|
|
/// True under the application shell, which owns the single navigation bar.
|
|
final bool embedded;
|
|
|
|
/// Advances when the shared socket is replaced. The mounted controller
|
|
/// reloads the list and the selected detail without losing the selection.
|
|
final int syncToken;
|
|
|
|
/// Receives the run id an accepted launch names, so the composition can open
|
|
/// the existing run route. The feature never navigates on its own.
|
|
final ValueChanged<int>? onRunStarted;
|
|
final ValueChanged<int>? onViewPipelineRuns;
|
|
|
|
/// The pipeline a deep link names, opened after the list read starts.
|
|
final int? initialPipelineId;
|
|
|
|
/// The pinned version for [initialPipelineId]; 0 means latest.
|
|
final int initialVersion;
|
|
|
|
/// The definition stage the route names for [initialPipelineId], or null.
|
|
///
|
|
/// The detail opens its Graph tab with this stage selected and its definition
|
|
/// pane; a key the pinned version does not declare opens the Graph tab with
|
|
/// nothing selected. Null keeps the ordinary default tab.
|
|
final String? initialStageKey;
|
|
|
|
@override
|
|
State<PipelinesScreen> createState() => _PipelinesScreenState();
|
|
}
|
|
|
|
class _PipelinesScreenState extends State<PipelinesScreen> {
|
|
late PipelinesController _controller;
|
|
|
|
/// Counts route stage requests so a re-read detail cannot replay an old one.
|
|
int _stageRequest = 0;
|
|
|
|
/// Whether the route's stage request has been handed to its named pin.
|
|
///
|
|
/// The screen, not the detail panel, owns this because the narrow layout
|
|
/// destroys the panel when it returns to the list: a deep link is a one-shot
|
|
/// intent, so coming back to the same pipeline later keeps the ordinary tab.
|
|
bool _stageRequestDone = false;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_controller = PipelinesController(
|
|
PipelinesRepository(widget.gateway),
|
|
pendingRunStore: SharedPreferencesPendingRunStore(widget.endpoint),
|
|
)..load();
|
|
final id = widget.initialPipelineId;
|
|
if (id != null) {
|
|
// The detail read owns its own failure state; the list read continues.
|
|
_controller.openPipeline(id, version: widget.initialVersion);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(PipelinesScreen oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.gateway != widget.gateway ||
|
|
oldWidget.endpoint != widget.endpoint) {
|
|
_controller.dispose();
|
|
_controller = PipelinesController(
|
|
PipelinesRepository(widget.gateway),
|
|
pendingRunStore: SharedPreferencesPendingRunStore(widget.endpoint),
|
|
)..load();
|
|
} else if (oldWidget.syncToken != widget.syncToken) {
|
|
// The socket was replaced; re-read through the existing controller so the
|
|
// selected pipeline and requested version survive the reconnect.
|
|
_controller.load();
|
|
} else if (oldWidget.initialPipelineId != widget.initialPipelineId ||
|
|
oldWidget.initialVersion != widget.initialVersion ||
|
|
oldWidget.initialStageKey != widget.initialStageKey) {
|
|
_stageRequest++;
|
|
_stageRequestDone = false;
|
|
final id = widget.initialPipelineId;
|
|
if (id == null) {
|
|
_controller.clearSelection();
|
|
} else if (!_isRoutePin(_controller.detail)) {
|
|
_controller.openPipeline(id, version: widget.initialVersion);
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
/// Whether [detail] is the pipeline and pin the route names.
|
|
///
|
|
/// The shown detail must have been *requested* for the route's version, not
|
|
/// merely have resolved to it: a latest route (`initialVersion == 0`) never
|
|
/// matches a detail still displayed from a pinned request, so a route change
|
|
/// from a pin to latest re-reads latest. The web compares its requested
|
|
/// version the same way. A pinned route additionally requires the reply's own
|
|
/// concrete version.
|
|
bool _isRoutePin(PipelineDetail? detail) {
|
|
final id = widget.initialPipelineId;
|
|
if (detail == null || id == null || detail.id != id) return false;
|
|
final version = widget.initialVersion;
|
|
if (_controller.selectedVersion != version) return false;
|
|
return version <= 0 || detail.resolvedVersion == version;
|
|
}
|
|
|
|
/// The route's stage request while it is still pending, or null once spent.
|
|
///
|
|
/// The request names one stage of one pinned pipeline. It is handed to the
|
|
/// detail only until that pin's reply has been shown: the screen consumes the
|
|
/// request as soon as the first reply for the current selection arrives, so a
|
|
/// spent deep link cannot replay its pane when the operator later returns to
|
|
/// the same pipeline. The panel still scopes the request to its named
|
|
/// pipeline and version, which is what keeps it off an unrelated detail.
|
|
String? _takeStageKey() {
|
|
final key = widget.initialStageKey;
|
|
final target = widget.initialPipelineId;
|
|
if (key == null || key.isEmpty || target == null) return null;
|
|
if (_stageRequestDone) return null;
|
|
final detail = _controller.detail;
|
|
if (detail == null) return key;
|
|
_stageRequestDone = true;
|
|
return _isRoutePin(detail) ? key : null;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AnimatedBuilder(
|
|
animation: _controller,
|
|
builder: (context, _) {
|
|
final stageKey = _takeStageKey();
|
|
final body = LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final wide = constraints.maxWidth >= kPipelinesWideBreakpoint;
|
|
if (!wide) {
|
|
return _controller.hasSelection
|
|
? PipelineDetailPanel(
|
|
controller: _controller,
|
|
gateway: widget.gateway,
|
|
showBack: true,
|
|
onRunStarted: widget.onRunStarted,
|
|
onViewPipelineRuns: widget.onViewPipelineRuns,
|
|
stageKey: stageKey,
|
|
stagePipelineId: widget.initialPipelineId,
|
|
stageVersion: widget.initialVersion,
|
|
stageRequest: _stageRequest,
|
|
)
|
|
: PipelineListPanel(controller: _controller);
|
|
}
|
|
return Row(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Expanded(
|
|
flex: 2,
|
|
child: PipelineListPanel(controller: _controller),
|
|
),
|
|
_divider(context),
|
|
Expanded(
|
|
flex: 3,
|
|
child: PipelineDetailPanel(
|
|
controller: _controller,
|
|
gateway: widget.gateway,
|
|
showBack: false,
|
|
onRunStarted: widget.onRunStarted,
|
|
onViewPipelineRuns: widget.onViewPipelineRuns,
|
|
stageKey: stageKey,
|
|
stagePipelineId: widget.initialPipelineId,
|
|
stageVersion: widget.initialVersion,
|
|
stageRequest: _stageRequest,
|
|
),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
if (widget.embedded) return _embeddedBody(context, body);
|
|
return useCupertinoControls(context)
|
|
? _cupertinoShell(context, body)
|
|
: _materialShell(context, body);
|
|
},
|
|
);
|
|
}
|
|
|
|
/// The shell owns the navigation bar here, so the content keeps a native
|
|
/// Refresh action without adding a second bar.
|
|
Widget _embeddedBody(BuildContext context, Widget body) {
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Align(
|
|
alignment: AlignmentDirectional.centerEnd,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(horizontal: 8),
|
|
child: _refreshButton(context),
|
|
),
|
|
),
|
|
Expanded(child: body),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _refreshButton(BuildContext context) {
|
|
if (useCupertinoControls(context)) {
|
|
return Semantics(
|
|
button: true,
|
|
label: 'Refresh',
|
|
child: CupertinoButton(
|
|
padding: EdgeInsets.zero,
|
|
onPressed: _controller.load,
|
|
child: const Icon(CupertinoIcons.refresh),
|
|
),
|
|
);
|
|
}
|
|
return IconButton(
|
|
tooltip: 'Refresh',
|
|
onPressed: _controller.load,
|
|
icon: const Icon(Icons.refresh),
|
|
);
|
|
}
|
|
|
|
Widget _divider(BuildContext context) {
|
|
if (useCupertinoControls(context)) {
|
|
return Container(
|
|
width: 1,
|
|
color: CupertinoColors.separator.resolveFrom(context),
|
|
);
|
|
}
|
|
return const VerticalDivider(width: 1);
|
|
}
|
|
|
|
Widget _materialShell(BuildContext context, Widget body) {
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: const Text('Pipelines'),
|
|
actions: [_refreshButton(context)],
|
|
),
|
|
body: SafeArea(child: body),
|
|
);
|
|
}
|
|
|
|
Widget _cupertinoShell(BuildContext context, Widget body) {
|
|
return CupertinoPageScaffold(
|
|
navigationBar: CupertinoNavigationBar(
|
|
middle: const Text('Pipelines'),
|
|
trailing: _refreshButton(context),
|
|
),
|
|
child: SafeArea(top: false, child: body),
|
|
);
|
|
}
|
|
}
|