143 lines
4.7 KiB
Dart
143 lines
4.7 KiB
Dart
import '../../../core/api_gateway.dart';
|
|
|
|
/// Merge a visit by sequence without allowing stale status or blank sparse
|
|
/// deltas to erase evidence already held by the detail cache.
|
|
List<JsonMap> upsertRunStep(List<JsonMap> steps, JsonMap delta) {
|
|
final sequence = delta['sequence'] is num
|
|
? (delta['sequence'] as num).toInt()
|
|
: 0;
|
|
final index = steps.indexWhere((step) => step['sequence'] == sequence);
|
|
if (index < 0) {
|
|
final result = [...steps, _stepFields({}, delta, sequence)];
|
|
result.sort(
|
|
(a, b) => ((a['sequence'] as num?) ?? 0).compareTo(
|
|
(b['sequence'] as num?) ?? 0,
|
|
),
|
|
);
|
|
return result;
|
|
}
|
|
final old = steps[index];
|
|
final incomingStatus = '${delta['status'] ?? ''}';
|
|
final oldStatus = '${old['status'] ?? ''}';
|
|
if (_stale(oldStatus, incomingStatus)) return steps;
|
|
final merged = _stepFields(old, delta, sequence);
|
|
if (_same(old, merged)) return steps;
|
|
final result = [...steps];
|
|
result[index] = merged;
|
|
return result;
|
|
}
|
|
|
|
JsonMap _stepFields(JsonMap old, JsonMap delta, int sequence) {
|
|
final oldStatus = '${old['status'] ?? ''}';
|
|
final incoming = '${delta['status'] ?? ''}';
|
|
return {
|
|
...old,
|
|
'sequence': sequence,
|
|
for (final key in ['stage', 'outcome', 'target', 'diagnostic'])
|
|
key: _blank(delta[key]) ? old[key] ?? '' : delta[key],
|
|
'status': _advance(oldStatus, incoming),
|
|
};
|
|
}
|
|
|
|
bool _stale(String old, String incoming) {
|
|
if (_blank(incoming)) return false;
|
|
final before = _rank(old);
|
|
final after = _rank(incoming);
|
|
return before >= 0 &&
|
|
after >= 0 &&
|
|
(after < before || (before == 2 && after == 2 && old != incoming));
|
|
}
|
|
|
|
String _advance(String old, String incoming) {
|
|
if (_blank(incoming)) return old;
|
|
final before = _rank(old);
|
|
final after = _rank(incoming);
|
|
if (before < 0 || (after >= 0 && after > before && before < 2)) {
|
|
return incoming;
|
|
}
|
|
if (before < 2 && after == before) return incoming;
|
|
return old;
|
|
}
|
|
|
|
int _rank(String status) => switch (status.trim().toLowerCase()) {
|
|
'running' || 'waiting' => 1,
|
|
'completed' || 'failed' || 'canceled' || 'interrupted' => 2,
|
|
_ => -1,
|
|
};
|
|
|
|
bool _same(JsonMap a, JsonMap b) =>
|
|
a.length == b.length && a.entries.every((e) => b[e.key] == e.value);
|
|
|
|
/// Compact graph evidence is intentionally allowlisted. It retains latest
|
|
/// visit-by-stage and distinct outcome routes, not arbitrary frame diagnostics.
|
|
JsonMap? mergeGraphEvidence(JsonMap? current, JsonMap frame) {
|
|
final incomingEvidence = frame['graph_evidence'];
|
|
final graphVisits = frame['graph_visits'];
|
|
final step = frame['step'];
|
|
if (incomingEvidence is! Map && graphVisits is! List && step is! Map) {
|
|
return current;
|
|
}
|
|
var visits = <JsonMap>[];
|
|
final oldVisits = current?['visits'];
|
|
if (oldVisits is List) {
|
|
visits = oldVisits
|
|
.whereType<Map>()
|
|
.map((v) => Map<String, dynamic>.from(v))
|
|
.toList();
|
|
}
|
|
final additions = <dynamic>[];
|
|
if (incomingEvidence is Map && incomingEvidence['visits'] is List) {
|
|
additions.addAll(incomingEvidence['visits'] as List);
|
|
}
|
|
if (graphVisits is List) additions.addAll(graphVisits);
|
|
if (step is Map) additions.add(step);
|
|
for (final item in additions.whereType<Map>()) {
|
|
final delta = Map<String, dynamic>.from(item);
|
|
visits = upsertRunStep(visits, {
|
|
'sequence': delta['sequence'],
|
|
'stage': delta['stage'],
|
|
'status': delta['status'],
|
|
'outcome': delta['outcome'],
|
|
'target': delta['target'],
|
|
});
|
|
}
|
|
final latestByStage = <String, int>{};
|
|
final routeSequence = <String, int>{};
|
|
for (final visit in visits) {
|
|
final sequence = (visit['sequence'] as num?)?.toInt() ?? 0;
|
|
final stage = '${visit['stage'] ?? ''}';
|
|
latestByStage[stage] = sequence;
|
|
if (!_blank(visit['outcome']) && !_blank(visit['target'])) {
|
|
routeSequence['$stage\u0000${visit['outcome']}\u0000${visit['target']}'] =
|
|
sequence;
|
|
}
|
|
}
|
|
visits = visits
|
|
.where((visit) {
|
|
final sequence = (visit['sequence'] as num?)?.toInt() ?? 0;
|
|
final stage = '${visit['stage'] ?? ''}';
|
|
final route = '$stage\u0000${visit['outcome']}\u0000${visit['target']}';
|
|
return latestByStage[stage] == sequence ||
|
|
routeSequence[route] == sequence;
|
|
})
|
|
.map(
|
|
(visit) => <String, dynamic>{
|
|
for (final key in [
|
|
'sequence',
|
|
'stage',
|
|
'status',
|
|
'outcome',
|
|
'target',
|
|
])
|
|
key: visit[key],
|
|
},
|
|
)
|
|
.toList();
|
|
final complete =
|
|
current?['complete'] == true ||
|
|
(incomingEvidence is Map && incomingEvidence['complete'] == true);
|
|
return {'complete': complete, 'visits': visits};
|
|
}
|
|
|
|
bool _blank(dynamic value) => '${value ?? ''}'.trim().isEmpty;
|