Files
WebHooker/app/components/RouteEditor.vue
T
翅膀 84fc63663e feat(console): confirm removing filled editor rows
Filter conditions and groups, delivery targets, saved fragments and forge
hosts vanished on a single click, taking whatever had been typed with
them. Rows holding content now ask first, while empty, never-filled
rows (`isBlankNode`: default operator, no path, no values, not negated)
are still removed directly.
2026-10-17 00:58:24 +08:00

594 lines
18 KiB
Vue

<script setup lang="ts">
import { computed, reactive, ref, watch } from "vue";
import type { Filter, FilterNode, NamedFragment, Route, RouteTarget, RouteTemplate } from "~/types";
import { FRAGMENT_PRESETS, ROUTE_TEMPLATES } from "~/types";
import type { NodeForm } from "~/composables/useFilterNode";
import {
blankLeafForm,
blankNode,
nodeToForm,
nodeFormToRouteFilters,
formToNode,
} from "~/composables/useFilterNode";
interface TargetForm {
platform: "discord" | "telegram" | "feishu";
channelId: string;
threadId: string;
chatId: string;
topicId: string;
}
const props = withDefaults(
defineProps<{ open: boolean; route: Route | null; saving: boolean; groupId?: string | null }>(),
{ groupId: null },
);
const emit = defineEmits<{ (e: "close"): void; (e: "save", route: Route): void }>();
const { t } = useI18n();
const { confirm } = useConfirm();
const isEdit = computed(() => props.route != null);
const discordRoles = computed({
get: () =>
form.discordRolesText
.split(",")
.map((role) => role.trim())
.filter(Boolean),
set: (roles: string[]) => {
form.discordRolesText = roles.join(", ");
},
});
const filterError = ref("");
const targetError = ref("");
const formError = ref("");
const blankTarget = (): TargetForm => ({
platform: "discord",
channelId: "",
threadId: "",
chatId: "",
topicId: "",
});
const form = reactive({
id: "",
name: "",
enabled: true,
fallback: false,
stop: false,
discordRolesText: "",
targets: [] as TargetForm[],
});
const root = ref<NodeForm>(blankNode("all"));
const { fragments, load: loadFragments, save: saveFragments } = useFragmentsApi();
const fragmentName = ref("");
const fragmentError = ref("");
const testPayload = ref("");
const testEvent = ref("");
const testResult = ref<{ matched: boolean; explanation: string } | null>(null);
const testError = ref("");
const testing = ref(false);
function applyTemplate(tmpl: RouteTemplate): void {
form.id = tmpl.id;
form.name = t(tmpl.nameKey);
form.targets = [blankTarget()];
root.value = tmpl.filters.length ? nodeToForm({ all: tmpl.filters }) : blankNode("all");
}
function addTarget(): void {
form.targets.push(blankTarget());
}
async function removeTarget(target: TargetForm): Promise<void> {
const filled = [target.channelId, target.threadId, target.chatId, target.topicId].some((v) =>
v.trim(),
);
if (filled) {
const n = form.targets.indexOf(target) + 1;
if (!(await confirm({ title: t("confirm.removeTarget", { n }) }))) return;
}
const index = form.targets.indexOf(target);
if (index >= 0) form.targets.splice(index, 1);
}
function validateNode(nf: NodeForm): string | null {
if (nf.kind === "leaf") {
if (nf.leaf.type === "field" && !nf.leaf.path.trim()) return t("routeEditor.errPath");
if (nf.leaf.op !== "exists" && nf.leaf.values.every((v) => !v.trim()))
return t("routeEditor.errValues");
return null;
}
if (nf.kind === "all" || nf.kind === "any") {
if (nf.children.length === 0) return t("routeEditor.errGroupEmpty");
for (const c of nf.children) {
const err = validateNode(c);
if (err) return err;
}
return null;
}
if (nf.child) return validateNode(nf.child);
return t("routeEditor.errGroupEmpty");
}
function collect(): Route | null {
filterError.value = "";
targetError.value = "";
formError.value = "";
let filters: Filter[] = [];
let ast: FilterNode | undefined;
if (!form.fallback) {
const err = validateNode(root.value);
if (err) {
filterError.value = err;
return null;
}
const res = nodeFormToRouteFilters(root.value);
filters = res.filters;
ast = res.ast;
} else {
const res = nodeFormToRouteFilters(root.value);
const has = res.filters.length > 0 || res.ast !== undefined;
if (has) {
const err = validateNode(root.value);
if (err) {
filterError.value = err;
return null;
}
filters = res.filters;
ast = res.ast;
}
}
const targets: RouteTarget[] = [];
for (const tg of form.targets) {
if (tg.platform === "telegram") {
const chatId = tg.chatId.trim();
if (!chatId) continue;
targets.push({ platform: "telegram", chatId, topicId: tg.topicId.trim() || undefined });
} else if (tg.platform === "feishu") {
const chatId = tg.chatId.trim();
if (!chatId) continue;
targets.push({ platform: "feishu", chatId });
} else {
const channelId = tg.channelId.trim();
if (!channelId) continue;
targets.push({ platform: "discord", channelId, threadId: tg.threadId.trim() || undefined });
}
}
const discordRoles = form.discordRolesText
.split(",")
.map((s) => s.trim())
.filter(Boolean);
return {
id: form.id.trim(),
name: form.name.trim(),
enabled: form.enabled,
fallback: form.fallback || undefined,
stop: form.stop || undefined,
discordRoleIds: discordRoles.length ? discordRoles : undefined,
filters,
...(ast ? { ast } : {}),
targets,
};
}
function save(): void {
const route = collect();
if (!route) return;
if (!/^[a-z0-9][a-z0-9-]*$/.test(route.id)) {
formError.value = t("routeEditor.errIdFormat");
return;
}
if (!route.name) {
formError.value = t("routeEditor.errName");
return;
}
if (!route.targets.length) {
targetError.value = t("routeEditor.errTargets");
return;
}
form.targets.forEach((tg, i) => {
if ((tg.platform === "telegram" || tg.platform === "feishu") && !tg.chatId.trim()) {
targetError.value = t("routeEditor.errChat", { n: i + 1 });
} else if (tg.platform === "discord" && !tg.channelId.trim()) {
targetError.value = t("routeEditor.errChannel", { n: i + 1 });
}
});
if (targetError.value) return;
emit("save", route);
}
function close(): void {
emit("close");
}
function onOpenChange(open: boolean): void {
if (!open) close();
}
async function runTest(): Promise<void> {
testError.value = "";
testResult.value = null;
let payload: unknown;
try {
payload = JSON.parse(testPayload.value);
} catch {
testError.value = t("routeEditor.testInvalidJson");
return;
}
const node = formToNode(root.value);
if (!node) {
testError.value = t("routeEditor.errAddFilter");
return;
}
testing.value = true;
try {
testResult.value = await apiFetch<{ matched: boolean; explanation: string }>(
"/admin/api/test-match",
{
method: "POST",
body: JSON.stringify({ node, event: testEvent.value.trim() || undefined, payload }),
},
);
} catch (err) {
testError.value = err instanceof Error ? err.message : String(err);
} finally {
testing.value = false;
}
}
function insertNode(node: FilterNode): void {
const child = nodeToForm(node);
if (root.value.kind === "all" || root.value.kind === "any") {
root.value.children.push(child);
} else {
root.value = {
kind: "all",
leaf: blankLeafForm(),
children: [root.value, child],
child: null,
};
}
}
function insertFragment(frag: NamedFragment): void {
insertNode(frag.node);
}
async function saveAsFragment(): Promise<void> {
fragmentError.value = "";
const name = fragmentName.value.trim();
if (!name) {
fragmentError.value = t("routeEditor.fragmentsNameRequired");
return;
}
if (!props.groupId) return;
const node = formToNode(root.value);
if (!node) {
fragmentError.value = t("routeEditor.errAddFilter");
return;
}
const id = `frag-${Math.random().toString(36).slice(2, 10)}`;
const next: NamedFragment[] = [
...fragments.value.filter((f) => f.id !== id),
{ id, groupId: props.groupId, name, node },
];
try {
await saveFragments(props.groupId, next);
fragmentName.value = "";
} catch (err) {
fragmentError.value = err instanceof Error ? err.message : String(err);
}
}
async function deleteFragment(frag: NamedFragment): Promise<void> {
const groupId = props.groupId;
if (!groupId) return;
if (!(await confirm({ title: t("confirm.deleteFragment", { name: frag.name }) }))) return;
fragmentError.value = "";
const next = fragments.value.filter((f) => f.id !== frag.id);
try {
await saveFragments(groupId, next);
} catch (err) {
fragmentError.value = err instanceof Error ? err.message : String(err);
}
}
watch(
() => props.open,
(open) => {
if (!open) return;
const r = props.route;
form.id = r?.id ?? "";
form.name = r?.name ?? "";
form.enabled = r?.enabled ?? true;
form.fallback = r?.fallback ?? false;
form.stop = r?.stop ?? false;
form.discordRolesText = r?.discordRoleIds?.length ? r.discordRoleIds.join(", ") : "";
form.targets =
r && r.targets.length
? r.targets.map((tg) => {
const merged = { ...blankTarget(), ...tg };
merged.platform =
merged.platform === "telegram" || merged.platform === "feishu"
? merged.platform
: "discord";
return merged;
})
: [blankTarget()];
if (r?.ast) {
root.value = nodeToForm(r.ast);
} else if (r && r.filters.length) {
root.value = nodeToForm({ all: r.filters });
} else {
root.value = blankNode("all");
}
filterError.value = "";
targetError.value = "";
formError.value = "";
testPayload.value = "";
testEvent.value = "";
testResult.value = null;
testError.value = "";
fragmentName.value = "";
fragmentError.value = "";
if (props.groupId) loadFragments(props.groupId);
},
);
</script>
<template>
<RcDialog
:open="open"
:title="isEdit ? t('routeEditor.editTitle') : t('routeEditor.newTitle')"
class="editor-dialog flex flex-col gap-0 max-h-[calc(100dvh-2rem)] overflow-hidden p-0 max-w-3xl"
@update:open="onOpenChange"
>
<template #header>
<div class="editor-head">
<div class="editor-heading">
<span class="editor-eyebrow">{{ t("routeEditor.eyebrow") }}</span>
<h2>{{ isEdit ? t("routeEditor.editTitle") : t("routeEditor.newTitle") }}</h2>
</div>
</div>
</template>
<form class="editor-body" @submit.prevent="save">
<section class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.sectionBasic") }}</h3>
<div v-if="!isEdit" class="templates">
<RcButton
v-for="tmpl in ROUTE_TEMPLATES"
:key="tmpl.id"
type="button"
variant="ghost"
size="sm"
:class="form.id === tmpl.id ? 'template-chip active' : 'template-chip'"
@click="applyTemplate(tmpl)"
>
{{ t(tmpl.nameKey) }}
</RcButton>
</div>
<div class="field">
<label>{{ t("routeEditor.name") }}</label>
<RcInput v-model="form.name" :placeholder="t('routeEditor.namePlaceholder')" required />
</div>
<div class="field">
<label>{{ t("routeEditor.id") }}</label>
<RcInput v-model="form.id" placeholder="my-route" required />
<div class="hint">{{ t("routeEditor.idHint") }}</div>
</div>
</section>
<section class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.sectionOptions") }}</h3>
<div class="field inline">
<RcSwitch v-model="form.enabled" :label="t('routeEditor.enabled')" />
</div>
<div class="field inline">
<RcCheckbox v-model="form.fallback" :label="t('routeEditor.fallback')" />
<span class="lbl-note">{{ t("routeEditor.fallbackHint") }}</span>
</div>
<div class="field inline">
<RcCheckbox v-model="form.stop" :label="t('routeEditor.stop')" />
<span class="lbl-note">{{ t("routeEditor.stopHint") }}</span>
</div>
<div class="field">
<label>{{ t("routeEditor.discordRoles") }}</label>
<RcTagInput
v-model="discordRoles"
separator=","
:placeholder="t('routeEditor.discordRolesPlaceholder')"
/>
<div class="hint">{{ t("routeEditor.discordRolesHint") }}</div>
</div>
</section>
<section class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.sectionFilters") }}</h3>
<div class="field">
<label>{{ t("routeEditor.filters") }}</label>
</div>
<div class="field">
<FilterNodeEditor :node="root" />
</div>
<div v-if="filterError" class="err">{{ filterError }}</div>
</section>
<section class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.testMatch") }}</h3>
<div class="field">
<RcInput v-model="testEvent" :placeholder="t('routeEditor.testEvent')" />
</div>
<div class="field">
<RcTextarea
v-model="testPayload"
class="test-payload"
:rows="6"
:placeholder="t('routeEditor.testPayloadPlaceholder')"
/>
</div>
<div class="field">
<RcButton type="button" variant="ghost" :loading="testing" @click="runTest">
{{ testing ? "…" : t("routeEditor.testRun") }}
</RcButton>
</div>
<div v-if="testResult" class="test-result" :class="{ ok: testResult.matched }">
<span class="test-badge">
{{
testResult.matched ? t("routeEditor.testMatched") : t("routeEditor.testNotMatched")
}}
</span>
<span class="test-explanation">{{ testResult.explanation }}</span>
</div>
<div v-if="testError" class="err">{{ testError }}</div>
</section>
<section v-if="groupId" class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.fragments") }}</h3>
<div class="fragments-presets">
<span class="hint">{{ t("routeEditor.fragmentsPresets") }}</span>
<div v-for="preset in FRAGMENT_PRESETS" :key="preset.id" class="fragment-row">
<span class="fragment-name">{{ t(preset.nameKey) }}</span>
<RcButton
type="button"
variant="ghost"
size="sm"
class="fragment-action"
@click="insertNode(preset.node)"
>
{{ t("routeEditor.fragmentsInsert") }}
</RcButton>
</div>
</div>
<div class="fragments-list">
<div v-if="!fragments.length" class="hint">{{ t("routeEditor.fragmentsEmpty") }}</div>
<div v-for="frag in fragments" :key="frag.id" class="fragment-row">
<span class="fragment-name">{{ frag.name }}</span>
<RcButton
type="button"
variant="ghost"
size="sm"
class="fragment-action"
@click="insertFragment(frag)"
>
{{ t("routeEditor.fragmentsInsert") }}
</RcButton>
<RcButton
type="button"
variant="destructive"
size="icon"
:title="t('routeEditor.fragmentsDelete')"
@click="deleteFragment(frag)"
>
✕
</RcButton>
</div>
</div>
<div class="field fragment-save">
<RcInput
v-model="fragmentName"
:placeholder="t('routeEditor.fragmentsNamePlaceholder')"
/>
<RcButton type="button" variant="ghost" @click="saveAsFragment">
{{ t("routeEditor.fragmentsSave") }}
</RcButton>
</div>
<div v-if="fragmentError" class="err">{{ fragmentError }}</div>
</section>
<section class="editor-section">
<h3 class="editor-section-title">{{ t("routeEditor.sectionTargets") }}</h3>
<div v-for="(tg, i) in form.targets" :key="i" class="target-row">
<RcSelect
v-model="tg.platform"
class="[grid-area:select]"
:options="[
{ label: 'Discord', value: 'discord' },
{ label: 'Telegram', value: 'telegram' },
{ label: t('routeEditor.platformFeishu'), value: 'feishu' },
]"
/>
<template v-if="tg.platform === 'discord'">
<RcInput
v-model="tg.channelId"
class="[grid-area:in1]"
:placeholder="t('routeEditor.channelPlaceholder')"
/>
<RcInput
v-model="tg.threadId"
class="[grid-area:in2]"
:placeholder="t('routeEditor.threadPlaceholder')"
/>
</template>
<template v-else-if="tg.platform === 'telegram'">
<RcInput
v-model="tg.chatId"
class="[grid-area:in1]"
:placeholder="t('routeEditor.chatPlaceholder')"
/>
<RcInput
v-model="tg.topicId"
class="[grid-area:in2]"
:placeholder="t('routeEditor.topicPlaceholder')"
/>
</template>
<template v-else>
<RcInput
v-model="tg.chatId"
class="[grid-area:in1]"
:placeholder="t('routeEditor.feishuChatPlaceholder')"
/>
</template>
<RcButton
type="button"
variant="destructive"
size="icon"
class="[grid-area:del] justify-self-end"
:title="t('routeEditor.remove')"
@click="removeTarget(tg)"
>
✕
</RcButton>
</div>
<RcButton type="button" variant="ghost" class="add-filter" @click="addTarget">
{{ t("routeEditor.addTarget") }}
</RcButton>
<div v-if="targetError" class="err">{{ targetError }}</div>
</section>
<div v-if="formError" class="err">{{ formError }}</div>
</form>
<template #footer>
<div class="editor-foot">
<RcButton variant="ghost" @click="close">{{ t("routeEditor.cancel") }}</RcButton>
<RcButton variant="primary" :loading="saving" @click="save">
{{ t("routeEditor.save") }}
</RcButton>
</div>
</template>
</RcDialog>
</template>
<style scoped>
:deep(.editor-foot) {
display: flex;
justify-content: flex-end;
gap: 0.5rem;
border-top: 1px solid rgb(var(--wh-border));
background: rgb(var(--wh-surface));
padding: 1rem 1.5rem;
box-shadow: 0 -8px 24px -16px rgba(15, 23, 42, 0.18);
}
</style>