feat(junction): establish stable complex junction structure
This commit is contained in:
1 parent
bd8b55e58b
commit
0a5a229ce3
22 files changed
+1386
-125
No files matched your search
+7
-1
@@ -24,7 +24,13 @@ fs.writeFileSync(
|
||||
fs.readFileSync(path.join(__dirname, '..', 'outputs', 'fengshu-er-road', 'native-traffic-signals.json')),
|
||||
);
|
||||
|
||||
const server = startWorkbench({ input, repoRoot: path.resolve(__dirname, '..'), dataRoot: root, port: 8899 });
|
||||
const server = startWorkbench({
|
||||
input,
|
||||
repoRoot: path.resolve(__dirname, '..'),
|
||||
dataRoot: root,
|
||||
debug: true,
|
||||
port: 8899,
|
||||
});
|
||||
const cleanup = () => {
|
||||
server.close(() => fs.rmSync(root, { recursive: true, force: true }));
|
||||
};
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
import fs from 'node:fs';
|
||||
import { expect, test } from '@playwright/test';
|
||||
import { strFromU8, unzipSync } from 'fflate';
|
||||
import type OLMap from 'ol/Map';
|
||||
import type VectorLayer from 'ol/layer/Vector';
|
||||
import type VectorSource from 'ol/source/Vector';
|
||||
|
||||
test.describe('workbench editing shell', () => {
|
||||
test.beforeEach(async ({ page }) => {
|
||||
@@ -194,4 +197,61 @@ test.describe('workbench editing shell', () => {
|
||||
await page.getByRole('button', { name: '放弃草稿' }).click();
|
||||
await expect(heading).toHaveValue(original);
|
||||
});
|
||||
|
||||
test('keeps complex junction structure and map selection linked across reload', async ({ page }) => {
|
||||
const initial = await page.request.get('/api/state').then((response) => response.json());
|
||||
const candidate = initial.debug.junctionCandidates.find((item: { nodeIds: string[] }) => item.nodeIds.length >= 3);
|
||||
expect(candidate).toBeTruthy();
|
||||
const acceptedResponse = await page.request.post('/api/junction-clusters', {
|
||||
data: { candidateId: candidate.id, nodeIds: candidate.nodeIds },
|
||||
});
|
||||
expect(acceptedResponse.ok()).toBe(true);
|
||||
const accepted = await acceptedResponse.json();
|
||||
const id = accepted.added.id;
|
||||
const structure = accepted.junctionStructures[`cluster:${id}`];
|
||||
expect(structure.arms.length).toBeGreaterThanOrEqual(3);
|
||||
await page.goto(`/junction/cluster/${encodeURIComponent(id)}`);
|
||||
const workspace = page.getByLabel('路口编辑工作区');
|
||||
await expect(workspace).toBeVisible();
|
||||
const armButtons = workspace.locator('.junction-workspace__object-list').first().getByRole('button');
|
||||
await expect(armButtons).toHaveCount(structure.arms.length);
|
||||
const map = await page
|
||||
.getByLabel('道路地图')
|
||||
.evaluateHandle((element) => (element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap);
|
||||
await armButtons.first().click();
|
||||
await expect(armButtons.first()).toHaveAttribute('aria-pressed', 'true');
|
||||
await expect
|
||||
.poll(async () =>
|
||||
page.getByLabel('道路地图').evaluate((element) => {
|
||||
const map = (element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap;
|
||||
const layer = map
|
||||
.getLayers()
|
||||
.getArray()
|
||||
.find((item) => item.getZIndex() === 89) as VectorLayer<VectorSource> | undefined;
|
||||
return layer?.getSource()?.getFeatures().length || 0;
|
||||
}),
|
||||
)
|
||||
.toBeGreaterThan(0);
|
||||
const sameMap = await page
|
||||
.getByLabel('道路地图')
|
||||
.evaluate(
|
||||
(element, original) =>
|
||||
(element as HTMLDivElement & { __roadWorkbenchMap: OLMap }).__roadWorkbenchMap === original,
|
||||
map,
|
||||
);
|
||||
expect(sameMap).toBe(true);
|
||||
await expect(workspace.getByText('路口参数', { exact: true })).toHaveCount(0);
|
||||
const scoped = await page.request
|
||||
.get(`/api/edit-state?cluster=${encodeURIComponent(id)}`)
|
||||
.then((response) => response.json());
|
||||
expect(scoped.handles.handles).toEqual([]);
|
||||
expect(scoped.junctionStructure.topologyFingerprint).toBe(structure.topologyFingerprint);
|
||||
await page.reload();
|
||||
await expect(armButtons).toHaveCount(structure.arms.length);
|
||||
await expect(armButtons.first()).toHaveAttribute('aria-pressed', 'false');
|
||||
const refreshed = await page.request.get('/api/state').then((response) => response.json());
|
||||
expect(refreshed.junctionStructures[`cluster:${id}`].arms.map((arm: { key: string }) => arm.key)).toEqual(
|
||||
structure.arms.map((arm: { key: string }) => arm.key),
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -93,3 +93,214 @@ assert.equal(diagnostics[1].severity, 'warning');
|
||||
assert.equal(diagnostics[1].objectKey, 'road-arm:road:east');
|
||||
|
||||
console.log('junction projection tests passed');
|
||||
|
||||
// Real geographic topology survives input and persisted-layer ordering changes.
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const { compileRoadModel, compileGeometry } = require('../src/compile/native-road');
|
||||
const { buildJunctionStructure } = require('../src/compile/junction-structure');
|
||||
const overrides = { schema: 'native-road-overrides/v1', overrides: [] };
|
||||
const baseline = compileRoadModel(
|
||||
fs.readFileSync(path.join(__dirname, 'fixtures/fengshu-er-road.osm'), 'utf8'),
|
||||
overrides,
|
||||
);
|
||||
const cluster = {
|
||||
id: 'identity',
|
||||
template: 'complex-junction-v1',
|
||||
nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147', '8613058676'],
|
||||
coreRadiusMeters: 24,
|
||||
};
|
||||
function compileCluster(input, config) {
|
||||
return compileGeometry(input, overrides, {
|
||||
edgeLines: false,
|
||||
junctionTemplates: { enabled: true, clusters: [config] },
|
||||
});
|
||||
}
|
||||
const layers = compileCluster(baseline, cluster);
|
||||
const ref = { type: 'cluster', id: cluster.id };
|
||||
const authoritative = projectJunctionStructure({ model: baseline, layers, junctionRef: ref });
|
||||
assert.equal(authoritative.arms.length, 5);
|
||||
assert.equal(authoritative.junctionRef.type, 'cluster');
|
||||
assert.equal(authoritative.capability.editable, false);
|
||||
assert.ok(authoritative.arms.every((arm) => arm.carriageways.length && arm.capability.reason));
|
||||
assert.deepEqual(buildJunctionStructure(JSON.parse(JSON.stringify(authoritative))), authoritative);
|
||||
assert.throws(
|
||||
() => buildJunctionStructure({ ...authoritative, provenance: { nodeIds: 'invalid' } }),
|
||||
/array of strings/,
|
||||
);
|
||||
assert.throws(
|
||||
() => buildJunctionStructure({ ...authoritative, capability: { editable: false, reason: ' ' } }),
|
||||
/requires a reason/,
|
||||
);
|
||||
const reversed = structuredClone(baseline);
|
||||
reversed.roads.reverse();
|
||||
reversed.endpoints.reverse();
|
||||
const reorderedLayers = compileCluster(reversed, { ...cluster, nodeIds: [...cluster.nodeIds].reverse() });
|
||||
reorderedLayers.roadSurface.features.reverse();
|
||||
const reordered = projectJunctionStructure({ model: reversed, layers: reorderedLayers, junctionRef: ref });
|
||||
for (const kind of ['arms', 'corners', 'facilities'])
|
||||
assert.deepEqual(reordered[kind].map((item) => item.key).sort(), authoritative[kind].map((item) => item.key).sort());
|
||||
assert.equal(reordered.topologyFingerprint, authoritative.topologyFingerprint);
|
||||
function closeCoordinates(actual, expected) {
|
||||
assert.equal(actual.length, expected.length);
|
||||
actual.forEach((value, index) => {
|
||||
if (Array.isArray(value)) closeCoordinates(value, expected[index]);
|
||||
else assert.ok(Math.abs(value - expected[index]) < 1e-9, `${value} != ${expected[index]}`);
|
||||
});
|
||||
}
|
||||
for (const [name, collection] of Object.entries(layers)) {
|
||||
const originalFeatures = (collection?.features || []).filter((feature) => feature.properties?.object_key);
|
||||
const recompiledFeatures = new Map(
|
||||
(reorderedLayers[name]?.features || []).map((feature) => [feature.properties?.native_id, feature]),
|
||||
);
|
||||
for (const feature of originalFeatures) {
|
||||
const recompiled = recompiledFeatures.get(feature.properties.native_id);
|
||||
assert.ok(recompiled, feature.properties.native_id);
|
||||
assert.equal(recompiled.properties.object_key, feature.properties.object_key);
|
||||
closeCoordinates(recompiled.geometry.coordinates, feature.geometry.coordinates);
|
||||
}
|
||||
}
|
||||
assert.equal(
|
||||
projectJunctionStructure({ model: baseline, layers, junctionRef: { type: 'cluster', id: 'missing' } }),
|
||||
null,
|
||||
);
|
||||
const otherLayers = compileCluster(baseline, { ...cluster, id: 'other' });
|
||||
const combined = {
|
||||
roadSurface: {
|
||||
type: 'FeatureCollection',
|
||||
features: [...otherLayers.roadSurface.features, ...layers.roadSurface.features],
|
||||
},
|
||||
};
|
||||
assert.equal(projectJunctionStructure({ layers: combined, junctionRef: ref }).junctionKey, 'cluster:identity');
|
||||
assert.equal(
|
||||
projectJunctionStructure({ layers: combined, junctionRef: { type: 'cluster', id: 'other' } }).junctionKey,
|
||||
'cluster:other',
|
||||
);
|
||||
const objectKeys = new Set(
|
||||
[
|
||||
...authoritative.arms,
|
||||
...authoritative.corners,
|
||||
...authoritative.facilities,
|
||||
...authoritative.arms.flatMap((arm) => arm.carriageways),
|
||||
].map((item) => item.key),
|
||||
);
|
||||
for (const collection of Object.values(layers)) {
|
||||
for (const feature of collection?.features || []) {
|
||||
if (feature.properties?.cluster_id !== cluster.id || !feature.properties.object_key) continue;
|
||||
assert.ok(objectKeys.has(feature.properties.object_key), feature.properties.object_key);
|
||||
}
|
||||
}
|
||||
const sources = authoritative.arms.flatMap((arm) => arm.carriageways).flatMap((item) => item.provenance.roadIds);
|
||||
for (const id of sources) {
|
||||
const road = baseline.roads.find((item) => item.id === id);
|
||||
assert.ok(
|
||||
!(
|
||||
cluster.nodeIds.includes(String(road.sourceNodeIds[0])) &&
|
||||
cluster.nodeIds.includes(String(road.sourceNodeIds.at(-1)))
|
||||
),
|
||||
);
|
||||
}
|
||||
const removedId = sources[0];
|
||||
const removed = structuredClone(baseline);
|
||||
removed.roads = removed.roads.filter((road) => road.id !== removedId);
|
||||
removed.endpoints = removed.endpoints.filter((endpoint) => endpoint.roadId !== removedId);
|
||||
const afterRemoval = projectJunctionStructure({ layers: compileCluster(removed, cluster), junctionRef: ref });
|
||||
assert.notEqual(afterRemoval.topologyFingerprint, authoritative.topologyFingerprint);
|
||||
assert.ok(
|
||||
!afterRemoval.arms.flatMap((arm) => arm.carriageways).some((item) => item.provenance.roadIds.includes(removedId)),
|
||||
);
|
||||
assert.deepEqual(standardsDiagnostics(null), []);
|
||||
console.log('complex junction identity and provenance tests passed');
|
||||
|
||||
const signalFeatures = [
|
||||
{ properties: { signal_uid: 'signal:member', control_id: cluster.nodeIds[0] } },
|
||||
{ properties: { signal_uid: 'signal:node', node_id: cluster.nodeIds[1] } },
|
||||
{ properties: { signal_uid: `signal:${cluster.nodeIds[0]}`, control_id: 'elsewhere' } },
|
||||
{ properties: { signal_uid: 'signal:unscoped' } },
|
||||
];
|
||||
const withSignals = (features) =>
|
||||
projectJunctionStructure({ layers, junctionRef: ref, trafficSignals: { assemblies: { features } } });
|
||||
const signalStructure = withSignals(signalFeatures);
|
||||
const projectedSignals = signalStructure.facilities.filter((item) => item.kind === 'signal');
|
||||
assert.equal(projectedSignals.length, 2);
|
||||
assert.ok(projectedSignals.every((item) => !item.editable && !item.capability.editable));
|
||||
assert.deepEqual(
|
||||
projectedSignals.map((item) => item.provenance.featureIds),
|
||||
[['signal:member'], ['signal:node']],
|
||||
);
|
||||
assert.deepEqual(withSignals([...signalFeatures].reverse()), signalStructure);
|
||||
assert.deepEqual(buildJunctionStructure(JSON.parse(JSON.stringify(signalStructure))), signalStructure);
|
||||
assert.equal(withSignals([]).facilities.filter((item) => item.kind === 'signal').length, 0);
|
||||
assert.equal(
|
||||
withSignals([...signalFeatures, signalFeatures[0]]).facilities.find((item) => item.geometryRef === 'signal:member')
|
||||
.capability.reason,
|
||||
'source-ambiguous',
|
||||
);
|
||||
|
||||
const { resolveComplexJunctionTopology, classifyJunctionShape } = require('../src/compile/complex-junction');
|
||||
const { structureFromTopology } = require('../src/compile/junction-topology');
|
||||
for (const headings of [
|
||||
[0, 90, 180],
|
||||
[0, 90, 180, 270],
|
||||
[0, 60, 120, 180, 240, 300],
|
||||
]) {
|
||||
const syntheticModel = {
|
||||
roads: headings.map((angle) => ({ id: `road:${angle}`, sourceNodeIds: ['a', `outer:${angle}`], laneCount: 1 })),
|
||||
};
|
||||
const approaches = headings.map((angle) => ({
|
||||
segmentId: `segment:${angle}`,
|
||||
roadIds: [`road:${angle}`],
|
||||
widthMeters: 3.5,
|
||||
line: [
|
||||
[0, 0],
|
||||
[Math.sin((angle * Math.PI) / 180) * 30, Math.cos((angle * Math.PI) / 180) * 30],
|
||||
],
|
||||
}));
|
||||
const plans = new Map([
|
||||
['a', { node: [0, 0], approaches }],
|
||||
['b', { node: [1, 1], approaches: [] }],
|
||||
]);
|
||||
const helpers = {
|
||||
junctionPlans: plans,
|
||||
headingAtEndpoint: (line) => (Math.atan2(line[1][0], line[1][1]) * 180) / Math.PI,
|
||||
lineLengthMeters: () => 30,
|
||||
distanceMeters: (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]),
|
||||
};
|
||||
const topology = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
|
||||
assert.equal(topology.arms.length, headings.length);
|
||||
const shape = classifyJunctionShape(topology.arms, [0, 0], helpers);
|
||||
assert.equal(structureFromTopology(topology, shape, [0, 0], []).shape.effectiveArmCount, headings.length);
|
||||
if (headings.length === 4) {
|
||||
approaches[0].line[1] = [0, 50];
|
||||
const offset = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
|
||||
const offsetShape = classifyJunctionShape(offset.arms, [0, 0], helpers);
|
||||
assert.equal(offsetShape.kind, 'offset-cross');
|
||||
const offsetStructure = structureFromTopology(offset, offsetShape, [0, 0], []);
|
||||
assert.equal(offsetStructure.arms.length, 4);
|
||||
assert.deepEqual(
|
||||
offsetStructure.arms.map((arm) => arm.key),
|
||||
structureFromTopology(topology, shape, [0, 0], []).arms.map((arm) => arm.key),
|
||||
);
|
||||
}
|
||||
// Duplicate provenance never invents another editable object.
|
||||
approaches.push(approaches[0]);
|
||||
const duplicate = resolveComplexJunctionTopology(syntheticModel, { id: 'synthetic', nodeIds: ['a', 'b'] }, helpers);
|
||||
const duplicateStructure = structureFromTopology(duplicate, shape, [0, 0], []);
|
||||
assert.equal(duplicateStructure.arms.length, headings.length);
|
||||
assert.ok(
|
||||
duplicateStructure.arms
|
||||
.flatMap((arm) => arm.carriageways)
|
||||
.some((item) => item.capability.reason === 'source-ambiguous'),
|
||||
);
|
||||
syntheticModel.roads[1].sourceNodeIds = [];
|
||||
const missingSource = resolveComplexJunctionTopology(
|
||||
syntheticModel,
|
||||
{ id: 'synthetic', nodeIds: ['a', 'b'] },
|
||||
helpers,
|
||||
);
|
||||
assert.ok(
|
||||
structureFromTopology(missingSource, shape, [0, 0], [])
|
||||
.arms.flatMap((arm) => arm.carriageways)
|
||||
.some((item) => item.capability.reason === 'source-missing'),
|
||||
);
|
||||
}
|
||||
+103
-1
@@ -7,7 +7,14 @@ const path = require('path');
|
||||
const { compileInput } = require('../src/compile/compiler');
|
||||
const { compileRoadModel, loadOverrides } = require('../src/compile/native-road');
|
||||
const { ensureRevisionStore } = require('../src/compile/road-revisions');
|
||||
const { editPreview, editState, rebaseEdits, saveEdits } = require('../workbench/server');
|
||||
const {
|
||||
editPreview,
|
||||
editState,
|
||||
rebaseEdits,
|
||||
saveEdits,
|
||||
state: browseState,
|
||||
selectionFrom,
|
||||
} = require('../workbench/server');
|
||||
const { snapshot: outputSnapshot } = require('./fixture-baseline');
|
||||
|
||||
const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'workbench-edit-api-'));
|
||||
@@ -219,5 +226,100 @@ assert.notDeepEqual(
|
||||
'a saved constraint must change the compiled output, or saving cannot survive a refresh',
|
||||
);
|
||||
|
||||
// Typed scope must survive parsing and cannot silently choose the first key.
|
||||
assert.deepEqual(selectionFrom(new URLSearchParams('cluster=fixture-five-arm')), {
|
||||
type: 'cluster',
|
||||
id: 'fixture-five-arm',
|
||||
});
|
||||
assert.deepEqual(selectionFrom({ junction: '8005332807' }), { type: 'junction', id: '8005332807' });
|
||||
for (const invalid of [
|
||||
{ cluster: 'one', junction: 'two' },
|
||||
{ cluster: '' },
|
||||
{ cluster: {} },
|
||||
new URLSearchParams('cluster=one&cluster=two'),
|
||||
]) {
|
||||
assert.throws(() => selectionFrom(invalid), /selection/);
|
||||
}
|
||||
assert.throws(() => editPreview(area, { selection: { cluster: 'one', segment: 'two' } }), /selection/);
|
||||
|
||||
const cluster = {
|
||||
id: 'fixture-five-arm',
|
||||
template: 'complex-junction-v1',
|
||||
nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147', '8613058676'],
|
||||
coreRadiusMeters: 24,
|
||||
};
|
||||
const complexInput = {
|
||||
...input,
|
||||
outDir: path.join(workspace, 'outputs', 'complex'),
|
||||
stagingDir: path.join(workspace, 'outputs', '_complex'),
|
||||
options: { edgeLines: false, junctionTemplates: { enabled: true, clusters: [cluster] } },
|
||||
};
|
||||
const complexArea = compileInput(complexInput).area;
|
||||
const clusterState = editState(complexArea, selectionFrom({ cluster: cluster.id }));
|
||||
assert.deepEqual(clusterState.handles.handles, [], 'cluster selection must never fall through to node handles');
|
||||
assert.deepEqual(clusterState.junctionStructure.junctionRef, { type: 'cluster', id: cluster.id });
|
||||
assert.equal(clusterState.junctionStructure.shape.effectiveArmCount, 5);
|
||||
assert.equal(clusterState.junctionStructure.capability.editable, false);
|
||||
const complexTracked = trackedFiles.map(({ file }) => ({
|
||||
file,
|
||||
bytes: fs.readFileSync(file),
|
||||
mtimeMs: fs.statSync(file).mtimeMs,
|
||||
}));
|
||||
const emptyDocument = { ...clusterState.document, constraints: [], operations: [] };
|
||||
const clusterPreview = editPreview(complexArea, { document: emptyDocument, selection: { cluster: cluster.id } });
|
||||
assert.deepEqual(clusterPreview.handles.handles, []);
|
||||
assert.deepEqual(
|
||||
clusterPreview.junctionStructure,
|
||||
clusterState.junctionStructure,
|
||||
'preview and persisted compiler structure agree',
|
||||
);
|
||||
const browsing = browseState(complexArea);
|
||||
const unavailableStructureState = browseState({
|
||||
...complexArea,
|
||||
nativeRoad: {
|
||||
...complexArea.nativeRoad,
|
||||
junctionTemplates: {
|
||||
...complexArea.nativeRoad.junctionTemplates,
|
||||
clusters: [
|
||||
...complexArea.nativeRoad.junctionTemplates.clusters,
|
||||
{ id: 'not-compiled', template: 'complex-junction-v1', nodeIds: ['missing-1', 'missing-2'] },
|
||||
],
|
||||
},
|
||||
},
|
||||
});
|
||||
assert.equal(unavailableStructureState.junctionStructures['cluster:not-compiled'], undefined);
|
||||
assert.ok(browsing.standardsDiagnostics.length, 'browse state retains structure diagnostics');
|
||||
assert.equal(new Set(browsing.standardsDiagnostics.map((item) => item.id)).size, browsing.standardsDiagnostics.length);
|
||||
assert.ok(
|
||||
Object.values(browsing.junctionStructures).every(Boolean),
|
||||
'the structure index contains only available structures',
|
||||
);
|
||||
assert.deepEqual(browsing.junctionStructures[`cluster:${cluster.id}`], clusterState.junctionStructure);
|
||||
const simpleKey = Object.keys(browsing.junctionStructures).find(
|
||||
(key) => key.startsWith('node:') && !cluster.nodeIds.includes(key.slice(5)),
|
||||
);
|
||||
assert.ok(simpleKey, 'fixture includes a simple junction outside the cluster');
|
||||
const simpleState = editState(complexArea, selectionFrom({ junction: simpleKey.slice(5) }));
|
||||
assert.deepEqual(simpleState.junctionStructure, browsing.junctionStructures[simpleKey]);
|
||||
assert.equal(simpleState.junctionStructure.junctionRef.type, 'node');
|
||||
for (const item of clusterState.standardsDiagnostics) {
|
||||
assert.ok(browsing.standardsDiagnostics.some((candidate) => candidate.id === item.id));
|
||||
}
|
||||
assert.ok(simpleState.handles.handles.length);
|
||||
for (const type of ['cluster', 'junction']) {
|
||||
const missing = editState(complexArea, selectionFrom({ [type]: 'missing-junction' }));
|
||||
assert.equal(missing.junctionStructure, null);
|
||||
assert.deepEqual(missing.handles.handles, []);
|
||||
assert.deepEqual(missing.standardsDiagnostics, []);
|
||||
assert.equal(
|
||||
editPreview(complexArea, { document: emptyDocument, selection: { [type]: 'missing-junction' } }).junctionStructure,
|
||||
null,
|
||||
);
|
||||
}
|
||||
for (const tracked of complexTracked) {
|
||||
assert.deepEqual(fs.readFileSync(tracked.file), tracked.bytes, 'scoped reads and previews preserve active files');
|
||||
assert.equal(fs.statSync(tracked.file).mtimeMs, tracked.mtimeMs);
|
||||
}
|
||||
|
||||
fs.rmSync(workspace, { recursive: true, force: true });
|
||||
console.log('workbench edit API tests passed');
|
||||
Reference in new issue
Block a user