新增 Webhook 通知渠道

src/main/java/com/ghostchu/peerbanhelper/util/push/PushManagerImpl.java

@@ -47,6 +47,8 @@ public PushProvider createPushProvider(String name, String type, ConfigurationSe
             case "pushdeer" -> provider = PushDeerPushProvider.loadFromYaml(name, section, httpUtil);
             case "gotify" -> provider = GotifyPushProvider.loadFromYaml(name, section, httpUtil);
             case "ntfy" -> provider = NtfyPushProvider.loadFromYaml(name, section, httpUtil);
+            case "webhook" -> provider = WebhookPushProvider.loadFromYaml(name, section, httpUtil);
+            default -> provider = null;
         }
         return provider;
     }
@@ -63,6 +65,8 @@ public PushProvider createPushProvider(String name, String type, JsonObject json
             case "pushdeer" -> provider = PushDeerPushProvider.loadFromJson(name, jsonObject, httpUtil);
             case "gotify" -> provider = GotifyPushProvider.loadFromJson(name, jsonObject, httpUtil);
             case "ntfy" -> provider = NtfyPushProvider.loadFromJson(name, jsonObject, httpUtil);
+            case "webhook" -> provider = WebhookPushProvider.loadFromJson(name, jsonObject, httpUtil);
+            default -> provider = null;
         }
         return provider;
     }

src/main/java/com/ghostchu/peerbanhelper/util/push/impl/WebhookPushProvider.java

@@ -0,0 +1,252 @@
+package com.ghostchu.peerbanhelper.util.push.impl;
+
+import com.ghostchu.peerbanhelper.util.HTTPUtil;
+import com.ghostchu.peerbanhelper.util.TimeUtil;
+import com.ghostchu.peerbanhelper.util.json.JsonUtil;
+import com.ghostchu.peerbanhelper.util.push.AbstractPushProvider;
+import com.google.gson.JsonObject;
+import com.google.gson.annotations.SerializedName;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import okhttp3.MediaType;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import org.bspfsystems.yamlconfiguration.configuration.ConfigurationSection;
+import org.bspfsystems.yamlconfiguration.file.YamlConfiguration;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class WebhookPushProvider extends AbstractPushProvider {
+    private static final String DEFAULT_METHOD = "POST";
+    private static final String DEFAULT_CONTENT_TYPE = "application/json";
+    private static final String DEFAULT_BODY_TEMPLATE = """
+    {
+        "title":"{title}",
+        "content":"{content}",
+        "level":"{level}",
+        "date":"{date}",
+        "time":"{time}",
+        "datetime":"{datetime}",
+        "channelName":"{channelName}"
+    }
+    """;
+    //TODO: 改方法签名并重构各模块以支持 Level 参数
+    private static final Pattern LEVEL_PATTERN = Pattern.compile("\\[PeerBanHelper/([^]]+)]");
+
+    private final Config config;
+    private final String name;
+    private final HTTPUtil httpUtil;
+
+    public WebhookPushProvider(String name, Config config, HTTPUtil httpUtil) {
+        this.name = name;
+        this.config = config;
+        this.httpUtil = httpUtil;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public String getConfigType() {
+        return "webhook";
+    }
+
+    @Override
+    public JsonObject saveJson() {
+        return JsonUtil.readObject(JsonUtil.standard().toJson(config));
+    }
+
+    @Override
+    public ConfigurationSection saveYaml() {
+        YamlConfiguration section = new YamlConfiguration();
+        section.set("type", "webhook");
+        section.set("url", config.getUrl());
+        section.set("method", config.getMethod());
+        section.set("content_type", config.getContentType());
+        section.set("body_template", config.getBodyTemplate());
+        section.set("headers", config.getHeaders());
+        return section;
+    }
+
+    public static WebhookPushProvider loadFromJson(String name, JsonObject json, HTTPUtil httpUtil) {
+        Config config = JsonUtil.getGson().fromJson(json, Config.class);
+        if (config == null) {
+            throw new IllegalArgumentException("Invalid webhook config JSON for provider '" + name + "': deserialized Config is null");
+        }
+        if (config.getMethod() == null || config.getMethod().isBlank()) {
+            config.setMethod(DEFAULT_METHOD);
+        }
+        if (config.getContentType() == null || config.getContentType().isBlank()) {
+            config.setContentType(DEFAULT_CONTENT_TYPE);
+        }
+        if (config.getBodyTemplate() == null || config.getBodyTemplate().isBlank()) {
+            config.setBodyTemplate(DEFAULT_BODY_TEMPLATE);
+        }
+        if (config.getHeaders() == null) {
+            config.setHeaders(new HashMap<>());
+        }
+        return new WebhookPushProvider(name, config, httpUtil);
+    }
+
+    public static WebhookPushProvider loadFromYaml(String name, ConfigurationSection section, HTTPUtil httpUtil) {
+        var url = section.getString("url", "");
+        var method = section.getString("method", DEFAULT_METHOD);
+        var contentType = section.getString("content_type", DEFAULT_CONTENT_TYPE);
+        var bodyTemplate = section.getString(
+                "body_template",
+                DEFAULT_BODY_TEMPLATE
+        );
+        Map<String, String> headers = new HashMap<>();
+        var headersSection = section.getConfigurationSection("headers");
+        if (headersSection != null) {
+            for (String key : headersSection.getKeys(false)) {
+                headers.put(key, headersSection.getString(key, ""));
+            }
+        }
+        Config config = new Config(url, method, contentType, bodyTemplate, headers);
+        return new WebhookPushProvider(name, config, httpUtil);
+    }
+
+    @Override
+    public boolean push(String title, String content) {
+        if (config.getUrl() == null || config.getUrl().isBlank()) {
+            throw new IllegalArgumentException("Webhook URL cannot be empty");
+        }
+
+        String method = normalizeMethod(config.getMethod());
+        String contentType = normalizeContentType(config.getContentType());
+        String bodyTemplate = config.getBodyTemplate() == null ? "" : config.getBodyTemplate();
+        String renderedBody = renderTemplate(bodyTemplate, title, content, contentType);
+        RequestBody requestBody = createRequestBody(method, contentType, renderedBody);
+
+        String renderedUrl = renderTemplate(config.getUrl(), title, content, null);
+        Request.Builder requestBuilder = new Request.Builder().url(renderedUrl).method(method, requestBody);  
+
+        applyContentType(requestBuilder, method, requestBody);
+        applyCustomHeaders(requestBuilder);
+        Request request = requestBuilder.build();
+        try (Response response = httpUtil.newBuilder().build().newCall(request).execute()) {
+            if (!response.isSuccessful()) {
+                String responseBody = response.body() != null ? response.body().string() : "<empty>";
+                throw new IllegalStateException("HTTP failed while sending push messages to Webhook: " + responseBody);
+            }
+        } catch (IllegalStateException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new IllegalStateException("Failed to send push message to Webhook", e);
+        }
+        return true;
+    }
+
+    private String normalizeMethod(String method) {
+        if (method == null || method.isBlank()) {
+            return DEFAULT_METHOD;
+        }
+        String normalized = method.toUpperCase(Locale.ROOT);
+        return switch (normalized) {
+            case "GET", "POST" -> normalized;
+            default -> throw new IllegalArgumentException("Unsupported webhook method: " + method);
+        };
+    }
+
+    private String normalizeContentType(String contentType) {
+        if (contentType == null || contentType.isBlank()) {
+            return DEFAULT_CONTENT_TYPE;
+        }
+        MediaType parsed = MediaType.parse(contentType.trim());
+        return parsed != null ? parsed.toString() : DEFAULT_CONTENT_TYPE;
+    }
+
+    private RequestBody createRequestBody(String method, String contentType, String bodyContent) {
+        if ("GET".equals(method)) {
+            return null;
+        }
+        MediaType mediaType = MediaType.parse(contentType);
+        if (mediaType == null) {
+            mediaType = MediaType.parse(DEFAULT_CONTENT_TYPE);
+        }
+        if (bodyContent.isEmpty()) {
+            if ("POST".equals(method)) {
+                return RequestBody.create("", mediaType);
+            }
+            return null;
+        }
+        return RequestBody.create(bodyContent, mediaType);
+    }
+
+    private void applyContentType(Request.Builder requestBuilder, String method, RequestBody requestBody) {
+        if (!"GET".equals(method) && requestBody != null) {
+            MediaType mediaType = requestBody.contentType();
+            if (mediaType != null) {
+                requestBuilder.header("Content-Type", mediaType.toString());
+            } else {
+                requestBuilder.header("Content-Type", DEFAULT_CONTENT_TYPE);
+            }
+        }
+    }
+
+    private void applyCustomHeaders(Request.Builder requestBuilder) {
+        if (config.getHeaders() == null) {
+            return;
+        }
+        config.getHeaders().forEach((headerKey, headerValue) -> {
+            if (headerKey != null && !headerKey.isBlank() && headerValue != null) {
+                requestBuilder.header(headerKey, headerValue);
+            }
+        });
+    }
+
+    private String renderTemplate(String template, String title, String content, String contentType) {
+        OffsetDateTime now = OffsetDateTime.now();
+        String date = TimeUtil.formatDateOnly(System.currentTimeMillis());
+        String time = TimeUtil.formatTimeOnly(System.currentTimeMillis());
+        String datetime = TimeUtil.formatDateTime(System.currentTimeMillis());
+        boolean json = contentType != null && contentType.toLowerCase(Locale.ROOT).contains("json");
+        java.util.function.UnaryOperator<String> esc = v -> {
+            if (v == null) return "";
+            if (!json) return v;
+            String s = JsonUtil.standard().toJson(v); // 引号包裹的转义字符串
+            return s.substring(1, s.length() - 1);    // 去掉外层引号
+        };
+        return template
+            .replace("{title}", esc.apply(title))
+            .replace("{content}", esc.apply(content))
+            .replace("{level}", esc.apply(extractLevel(title)))
+            .replace("{date}", esc.apply(date))
+            .replace("{time}", esc.apply(time))
+            .replace("{datetime}", esc.apply(datetime))
+            .replace("{channelName}", esc.apply(name));
+    }
+
+    private String extractLevel(String title) {
+        Matcher matcher = LEVEL_PATTERN.matcher(title);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return "INFO";
+    }
+
+    @AllArgsConstructor
+    @NoArgsConstructor
+    @Data
+    public static class Config {
+        @SerializedName("url")
+        private String url;
+        @SerializedName("method")
+        private String method;
+        @SerializedName("content_type")
+        private String contentType;
+        @SerializedName("body_template")
+        private String bodyTemplate;
+        @SerializedName("headers")
+        private Map<String, String> headers;
+    }
+}

src/main/resources/assets/credit.txt

@@ -68,6 +68,7 @@ PeerBanHelper Credit
     cxzlw
     david082321
     DDSRem
+    gongfuture
     Kaffu-Chino
     mahoshojoHCG
     MirrorCY

webui/src/api/model/push.ts

@@ -6,7 +6,18 @@ export enum PushType {
   Bark = 'bark',
   PushDeer = 'pushdeer',
   Gotify = 'gotify',
-  Ntfy = 'ntfy'
+  Ntfy = 'ntfy',
+  Webhook = 'webhook'
+}
+
+export enum WebhookMethod {
+  GET = 'GET',
+  POST = 'POST'
+}
+
+export enum WebhookContentType {
+  Json = 'application/json',
+  PlainText = 'text/plain'
 }
 
 export enum SMTPEncryption {
@@ -79,6 +90,14 @@ export interface NtfyConfig {
   tags?: string
 }
 
+export interface WebhookConfig {
+  url: string
+  method: WebhookMethod
+  content_type: WebhookContentType
+  body_template: string
+  headers: Record<string, string>
+}
+
 export type PushConfig = {
   name: string
 } & (
@@ -90,4 +109,5 @@ export type PushConfig = {
   | { type: PushType.PushDeer; config: PushDeerConfig }
   | { type: PushType.Gotify; config: GotifyConfig }
   | { type: PushType.Ntfy; config: NtfyConfig }
+  | { type: PushType.Webhook; config: WebhookConfig }
 )

webui/src/views/settings/components/config/components/push/editPush.vue

@@ -67,6 +67,9 @@
             <a-radio :value="PushType.Ntfy">{{
               t('page.settings.tab.config.push.form.type.' + PushType.Ntfy)
             }}</a-radio>
+            <a-radio :value="PushType.Webhook">{{
+              t('page.settings.tab.config.push.form.type.' + PushType.Webhook)
+            }}</a-radio>
           </a-grid>
         </a-radio-group>
       </a-form-item>
@@ -128,6 +131,9 @@ const formMap: Record<PushType, Component> = {
   ),
   [PushType.Ntfy]: defineAsyncComponent(
     () => import('@/views/settings/components/config/components/push/forms/ntfyForm.vue')
+  ),
+  [PushType.Webhook]: defineAsyncComponent(
+    () => import('@/views/settings/components/config/components/push/forms/webhookForm.vue')
   )
 }