WeKnora/internal/handler/plugin_forms.go

367 lines
13 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

package handler
import (
"encoding/json"
stderrors "errors"
"html/template"
"net/http"
"net/url"
"os"
"strings"
"github.com/gin-gonic/gin"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/plugin/activate"
"github.com/Tencent/WeKnora/internal/plugin/configschema"
"github.com/Tencent/WeKnora/internal/plugin/install"
"github.com/Tencent/WeKnora/internal/plugin/manifest"
pluginoauth "github.com/Tencent/WeKnora/internal/plugin/oauth"
"github.com/Tencent/WeKnora/internal/plugin/registry"
"github.com/Tencent/WeKnora/internal/plugin/tenancy"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/Tencent/WeKnora/pluginsdk/pluginapi"
)
// PluginFormsHandler serves what plugin forms need from the plugin while
// they are being filled: dynamic choices (x-options) and OAuth connections
// (x-oauth).
type PluginFormsHandler struct {
registry *registry.Registry
tenancy *tenancy.Service
invoker *activate.Invoker
plugins interfaces.PluginRepository
dataSources interfaces.DataSourceRepository
webSearch interfaces.WebSearchProviderRepository
oauth *pluginoauth.Service
}
// NewPluginFormsHandler creates the handler.
func NewPluginFormsHandler(
reg *registry.Registry, t *tenancy.Service, iv *activate.Invoker, plugins interfaces.PluginRepository,
dataSources interfaces.DataSourceRepository, webSearch interfaces.WebSearchProviderRepository,
oauth *pluginoauth.Service,
) *PluginFormsHandler {
return &PluginFormsHandler{
registry: reg, tenancy: t, invoker: iv, plugins: plugins, dataSources: dataSources, webSearch: webSearch,
oauth: oauth,
}
}
// PluginOptionsRequest asks a plugin for a field's choices.
type PluginOptionsRequest struct {
Name string `json:"name" binding:"required"`
Field string `json:"field" binding:"required"`
// Scope is system, tenant or instance.
Scope string `json:"scope" binding:"required"`
// Contribution is "<point>/<id>" of the instance ("connectors/jira").
Contribution string `json:"contribution"`
// InstanceID is the instance being edited; its stored secrets fill in
// the fields the form did not change.
InstanceID string `json:"instanceId"`
// Values are what the form holds now, in the scope's shape.
Values map[string]any `json:"values"`
Query string `json:"query"`
}
// Options godoc
// @Summary 插件表单的动态选项
// @Description 用表单当前的值(未修改的密钥用已存的值补齐)向插件取某个字段的可选项(x-options)
// @Tags Plugins
// @Accept json
// @Produce json
// @Param id path string true "插件 ID"
// @Param request body PluginOptionsRequest true "请求"
// @Success 200 {object} map[string]interface{}
// @Security Bearer
// @Router /plugins/{id}/options [post]
func (h *PluginFormsHandler) Options(c *gin.Context) {
limitJSONBody(c, 1<<20)
var req PluginOptionsRequest
if err := c.ShouldBindJSON(&req); err != nil {
_ = c.Error(errors.NewBadRequestError("name, field and scope are required"))
return
}
ctx := c.Request.Context()
m, ok := h.codePlugin(c, c.Param("id"), req.Scope)
if !ok {
return
}
tenantID := c.GetUint64(types.TenantIDContextKey.String())
values := req.Values
if values == nil {
values = map[string]any{}
}
var override activate.ConfigOverride
var instance map[string]any
switch req.Scope {
case pluginapi.OptionsScopeSystem:
stored, _, err := install.OpenSystemConfig(ctx, h.plugins, m)
if err != nil {
h.fail(c, err)
return
}
override.System = mergeForm(m.Config.SystemSchema, stored, values)
case pluginapi.OptionsScopeTenant:
stored, _, err := h.tenancy.OpenConfig(ctx, tenantID, m.ID)
if err != nil {
h.fail(c, err)
return
}
override.Tenant = mergeForm(m.Config.TenantSchema, stored, values)
case pluginapi.OptionsScopeInstance:
var err error
if instance, err = h.instanceValues(c, tenantID, req, values); err != nil {
h.fail(c, err)
return
}
default:
_ = c.Error(errors.NewBadRequestError("scope must be system, tenant or instance"))
return
}
in := pluginapi.OptionsInput{Field: req.Field, Scope: req.Scope, Contribution: req.Contribution, Query: req.Query}
var out pluginapi.OptionsOutput
err := h.invoker.CallOverriding(ctx, m, pluginapi.OptionsPath(req.Name), instance, override, in, &out)
if err != nil {
h.fail(c, err)
return
}
if out.Options == nil {
out.Options = []pluginapi.Option{}
}
c.JSON(http.StatusOK, gin.H{"success": true, "data": out})
}
// codePlugin finds a plugin with code the caller may ask for this scope.
func (h *PluginFormsHandler) codePlugin(c *gin.Context, id, scope string) (*manifest.Manifest, bool) {
ctx := c.Request.Context()
m, ok := h.registry.Plugin(id)
if !ok || (m.Runtime.Type != manifest.RuntimeHost && m.Runtime.Type != manifest.RuntimeRemote) {
_ = c.Error(errors.NewNotFoundError("no such plugin with code"))
return nil, false
}
if scope == pluginapi.OptionsScopeSystem {
if !types.IsSystemAdminFromContext(ctx) {
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Forbidden: system administrators only"})
return nil, false
}
return m, true
}
tenantID := c.GetUint64(types.TenantIDContextKey.String())
if on, err := h.tenancy.PluginEnabled(ctx, tenantID, id); err != nil || !on {
_ = c.Error(errors.NewNotFoundError("the plugin is not enabled in this workspace"))
return nil, false
}
return m, true
}
// mergeForm fills the fields a form left redacted ("***") or empty with the
// stored values.
func mergeForm(rawSchema json.RawMessage, stored, values map[string]any) map[string]any {
if len(rawSchema) == 0 {
return values
}
schema, err := configschema.Parse(rawSchema)
if err != nil {
return values
}
return configschema.Merge(schema, stored, values)
}
// instanceValues is the instance the form holds, with the stored instance's
// secrets filled in where the form has none (forms never receive secrets).
func (h *PluginFormsHandler) instanceValues(
c *gin.Context, tenantID uint64, req PluginOptionsRequest, values map[string]any,
) (map[string]any, error) {
point, _, _ := strings.Cut(req.Contribution, "/")
switch manifest.Point(point) {
case manifest.PointConnectors:
creds, _ := values["credentials"].(map[string]any)
if creds == nil {
creds = map[string]any{}
}
if req.InstanceID != "" {
ds, err := h.dataSources.FindByID(c.Request.Context(), req.InstanceID)
if err != nil || ds == nil || ds.TenantID != tenantID {
return nil, errInstanceNotFound
}
cfg, err := ds.ParseConfig()
if err != nil {
return nil, err
}
for k, v := range cfg.Credentials {
if s, _ := creds[k].(string); s == "" || s == types.RedactedSecretPlaceholder {
creds[k] = v
}
}
}
out := map[string]any{
"credentials": creds,
"settings": values["settings"],
"resourceIds": values["resourceIds"],
}
if out["settings"] == nil {
out["settings"] = map[string]any{}
}
return out, nil
case manifest.PointWebSearch:
out := map[string]any{}
for k, v := range values {
out[k] = v
}
if key, _ := out["api_key"].(string); req.InstanceID != "" &&
(key == "" || key == types.RedactedSecretPlaceholder) {
p, err := h.webSearch.GetByID(c.Request.Context(), tenantID, req.InstanceID)
if err != nil || p == nil {
return nil, errInstanceNotFound
}
out["api_key"] = p.Parameters.APIKey
}
return out, nil
default:
return values, nil
}
}
var errInstanceNotFound = stderrors.New("instance not found")
// fail maps a plugin form failure: the plugin's own field problems go back
// to the form as they are.
func (h *PluginFormsHandler) fail(c *gin.Context, err error) {
if stderrors.Is(err, errInstanceNotFound) {
_ = c.Error(errors.NewNotFoundError("instance not found"))
return
}
if pe, ok := pluginapi.AsError(err); ok {
switch pe.Code {
case pluginapi.CodeInvalidConfig, pluginapi.CodeUnauthorized, pluginapi.CodeBadRequest:
body := gin.H{"success": false, "error": gin.H{"code": string(pe.Code), "message": pe.Message}}
if pe.Details != nil && len(pe.Details.Fields) > 0 {
body["error"].(gin.H)["fields"] = pe.Details.Fields
}
c.JSON(http.StatusBadRequest, body)
return
case pluginapi.CodeNotFound:
_ = c.Error(errors.NewNotFoundError(pe.Message))
return
}
}
logger.Warnf(c.Request.Context(), "[plugin] form request to %s failed: %v", c.Param("id"), err)
c.JSON(http.StatusBadGateway, gin.H{"success": false, "error": gin.H{"message": err.Error()}})
}
// PluginOAuthStartRequest starts connecting an x-oauth field.
type PluginOAuthStartRequest struct {
Scope string `json:"scope" binding:"required"`
Contribution string `json:"contribution"`
Field string `json:"field" binding:"required"`
}
// OAuthStart godoc
// @Summary 开始插件字段的 OAuth 授权
// @Description 为 x-oauth 字段生成授权地址;授权完成后回调页把连接 ID 交回表单,令牌只保存在服务端
// @Tags Plugins
// @Accept json
// @Produce json
// @Param id path string true "插件 ID"
// @Param request body PluginOAuthStartRequest true "字段"
// @Success 200 {object} map[string]interface{}
// @Security Bearer
// @Router /plugins/{id}/oauth/start [post]
func (h *PluginFormsHandler) OAuthStart(c *gin.Context) {
var req PluginOAuthStartRequest
if err := c.ShouldBindJSON(&req); err != nil {
_ = c.Error(errors.NewBadRequestError("scope and field are required"))
return
}
m, ok := h.codePlugin(c, c.Param("id"), req.Scope)
if !ok {
return
}
target := pluginoauth.Target{
PluginID: m.ID, Scope: req.Scope, Contribution: req.Contribution, Field: req.Field,
}
if req.Scope != pluginapi.OptionsScopeSystem {
target.TenantID = c.GetUint64(types.TenantIDContextKey.String())
}
userID, _ := types.UserIDFromContext(c.Request.Context())
origin, base := appOrigin(c)
url, state, err := h.oauth.Start(c.Request.Context(), target, userID, origin, base)
if err != nil {
_ = c.Error(errors.NewBadRequestError(err.Error()))
return
}
c.JSON(http.StatusOK, gin.H{"success": true, "data": gin.H{
"authorizeUrl": url, "state": state, "redirectUri": base + pluginoauth.CallbackPath,
}})
}
// appOrigin is the app's origin (where the callback page reports back) and
// the base URL authorization servers send the browser to: APP_EXTERNAL_URL
// when set, else the origin the browser called from.
func appOrigin(c *gin.Context) (origin, base string) {
if ext := strings.TrimSuffix(strings.TrimSpace(os.Getenv("APP_EXTERNAL_URL")), "/"); ext != "" {
if u, err := url.Parse(ext); err == nil && u.Host != "" {
return u.Scheme + "://" + u.Host, ext
}
}
if o := c.GetHeader("Origin"); strings.HasPrefix(o, "http://") || strings.HasPrefix(o, "https://") {
return o, o
}
scheme := "http"
if c.Request.TLS != nil || strings.EqualFold(c.GetHeader("X-Forwarded-Proto"), "https") {
scheme = "https"
}
host := c.Request.Host
if fh := c.GetHeader("X-Forwarded-Host"); fh != "" {
host = fh
}
o := scheme + "://" + host
return o, o
}
var oauthDoneTemplate = template.Must(template.New("oauth").Parse(`<!doctype html>
<html><head><meta charset="utf-8"><title>WeKnora</title></head>
<body style="font:14px system-ui,sans-serif;padding:24px">
<p id="msg">{{.Message}}</p>
<script>
(function () {
var msg = {
type: 'weknora-plugin-oauth', state: {{.State}}, ok: {{.OK}},
connection: {{.Connection}}, error: {{.Error}}
};
if (window.opener && {{.Origin}}) {
window.opener.postMessage(msg, {{.Origin}});
window.close();
}
})();
</script>
</body></html>`))
// OAuthCallback is where authorization servers send the browser back. It
// needs no login (the state names the pending authorization) and answers
// with a page that hands the result to the form that opened it.
func (h *PluginFormsHandler) OAuthCallback(c *gin.Context) {
res := h.oauth.Complete(c.Request.Context(), c.Query("state"), c.Query("code"), c.Query("error"))
data := map[string]any{
"State": res.State, "Origin": res.Origin, "OK": res.Err == nil, "Connection": "", "Error": "",
"Message": "Connected. You can close this window.",
}
if res.Err != nil {
data["Error"], data["Message"] = res.Err.Error(), res.Err.Error()
} else {
data["Connection"] = configschema.OAuthRefPrefix + res.ConnectionID
}
c.Header("Content-Type", "text/html; charset=utf-8")
c.Header("Cache-Control", "no-store")
c.Header("Referrer-Policy", "no-referrer")
status := http.StatusOK
if res.Err != nil {
status = http.StatusBadRequest
}
c.Status(status)
_ = oauthDoneTemplate.Execute(c.Writer, data)
}