mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
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.
594 lines
18 KiB
Vue
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>
|