An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later
package model
import (
"bytes"
"errors"
"fmt"
"io/fs"
"net/url"
"os"
"path"
"path/filepath"
"sort"
"strings"
"text/template"
"time"
"github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/88250/lute/parse"
"github.com/88250/lute/render"
"github.com/gin-gonic/gin"
"github.com/siyuan-note/filelock"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/bazaar"
"github.com/siyuan-note/siyuan/kernel/filesys"
"github.com/siyuan-note/siyuan/kernel/search"
"github.com/siyuan-note/siyuan/kernel/sql"
"github.com/siyuan-note/siyuan/kernel/treenode"
"github.com/siyuan-note/siyuan/kernel/util"
"github.com/xrash/smetrics"
)
// TemplateSearchResult 描述了模板搜索结果。
type TemplateSearchResult struct {
Path string `json:"path"`
RelativePath string `json:"relativePath"`
Content string `json:"content"`
}
type TemplateDatabaseMode string
const (
TemplateDatabaseModeCopy TemplateDatabaseMode = "copy"
TemplateDatabaseModeReference TemplateDatabaseMode = "reference"
templateDatabaseModeAttr = "custom-sy-av-template-mode"
templateExportNameAttr = "custom-sy-template-export-name"
templateExportDirectoryAttr = "custom-sy-template-export-directory"
)
type DocSaveAsTemplateInfo struct {
Name string `json:"name"`
Directory string `json:"directory"`
HasDatabase bool `json:"hasDatabase"`
}
func RenderGoTemplate(templateContent string) (ret string, err error) {
return RenderGoTemplateAtInBox(templateContent, time.Now(), "")
}
// RenderGoTemplateAt 使用固定时间渲染 Go 模板,保证同一次业务操作中的多个模板结果一致。
func RenderGoTemplateAt(templateContent string, now time.Time) (ret string, err error) {
return RenderGoTemplateAtInBox(templateContent, now, "")
}
func RenderGoTemplateInBox(templateContent, boxID string) (ret string, err error) {
return RenderGoTemplateAtInBox(templateContent, time.Now(), boxID)
}
func RenderGoTemplateAtInBox(templateContent string, now time.Time, boxID string) (ret string, err error) {
tmpl := template.New("")
tplFuncMap := filesys.BuiltInTemplateFuncs()
tplFuncMap["now"] = func() time.Time { return now }
sql.SQLTemplateFuncs(&tplFuncMap, boxID)
tmpl = tmpl.Funcs(tplFuncMap)
tpl, err := tmpl.Parse(templateContent)
if err != nil {
return "", fmt.Errorf(Conf.Language(44), err.Error())
}
buf := &bytes.Buffer{}
buf.Grow(4096)
err = tpl.Execute(buf, nil)
if err != nil {
return "", fmt.Errorf(Conf.Language(44), err.Error())
}
ret = buf.String()
return
}
// RemoveTemplate 删除模板文件,路径必须限定在 <data>/templates/ 目录内,防止任意文件被删除
func RemoveTemplate(p string) (err error) {
root, rel, err := openTemplatePath(p)
if err != nil {
return err
}
defer root.Close()
abs := filepath.Join(root.Name(), rel)
filelock.Lock(abs)
defer filelock.Unlock(abs)
err = root.RemoveAll(rel)
if err != nil {
logging.LogErrorf("remove template failed: %s", err)
}
return
}
// getTemplateReadmePaths 返回模板包 README 的相对包根路径集合:恒含 README.md,并合并 template.json 的 readme 字段(大小写敏感)。
func getTemplateReadmePaths(templateDir string) map[string]struct{} {
paths := map[string]struct{}{"README.md": {}}
pkg, err := bazaar.ParsePackageJSON(filepath.Join(templateDir, "template.json"))
if err != nil {
return paths
}
for _, v := range pkg.Readme {
v = strings.TrimSpace(v)
if "" != v {
paths[v] = struct{}{}
}
}
return paths
}
func SearchTemplate(keyword string) (ret []*TemplateSearchResult) {
confSearchReadSnapshot := Conf.LoadSearch()
ret = []*TemplateSearchResult{}
templates := filepath.Join(util.DataDir, "templates")
if !util.IsPathRegularDirOrSymlinkDir(templates) {
return
}
groups, err := os.ReadDir(templates)
if err != nil {
logging.LogErrorf("read templates failed: %s", err)
return
}
sort.Slice(ret, func(i, j int) bool {
return util.PinYinCompare(filepath.Base(groups[i].Name()), filepath.Base(groups[j].Name()))
})
keyword = strings.TrimSpace(keyword)
type result struct {
item *TemplateSearchResult
score float64
}
var results []*result
keywords := strings.Fields(keyword)
for _, group := range groups {
if strings.HasPrefix(group.Name(), ".") {
continue
}
if group.IsDir() {
templateDir := filepath.Join(templates, group.Name())
manifestPath := filepath.Join(templateDir, "template.json")
if filelock.IsExist(manifestPath) {
pkg, parseErr := bazaar.ParsePackageJSON(manifestPath)
if parseErr != nil || !bazaar.IsValidInstalledPackage(pkg, group.Name()) {
continue
}
}
readmePaths := getTemplateReadmePaths(templateDir)
filelock.Walk(templateDir, func(path string, d fs.DirEntry, err error) error {
name := strings.ToLower(d.Name())
if strings.HasPrefix(name, ".") {
if d.IsDir() {
return filepath.SkipDir
}
return nil
}
if !strings.HasSuffix(name, ".md") {
return nil
}
rel, relErr := filepath.Rel(templateDir, path)
if relErr != nil {
return nil
}
if _, skip := readmePaths[filepath.ToSlash(rel)]; skip {
return nil
}
content := strings.TrimPrefix(path, templates)
content = strings.TrimSuffix(content, ".md")
p := filepath.Join(group.Name(), content)
score := 0.0
hit := true
for _, k := range keywords {
if strings.Contains(strings.ToLower(p), strings.ToLower(k)) {
score += smetrics.JaroWinkler(name, k, 0.7, 4)
} else {
hit = false
break
}
}
if hit {
content = strings.TrimPrefix(path, templates)
content = strings.TrimSuffix(content, ".md")
content = filepath.ToSlash(content)
_, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, confSearchReadSnapshot.CaseSensitive)
relativePath, relErr := filepath.Rel(templates, path)
if nil != relErr {
return nil
}
b := &TemplateSearchResult{Path: path, RelativePath: filepath.ToSlash(relativePath), Content: content}
results = append(results, &result{item: b, score: score})
}
return nil
})
} else {
name := strings.ToLower(group.Name())
if strings.HasPrefix(name, ".") || !strings.HasSuffix(name, ".md") || "README.md" == group.Name() {
continue
}
content := group.Name()
content = strings.TrimSuffix(content, ".md")
score := 0.0
hit := true
for _, k := range keywords {
if strings.Contains(strings.ToLower(content), strings.ToLower(k)) {
score += smetrics.JaroWinkler(name, k, 0.7, 4)
} else {
hit = false
break
}
}
if hit {
content = filepath.ToSlash(content)
_, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, confSearchReadSnapshot.CaseSensitive)
b := &TemplateSearchResult{Path: filepath.Join(templates, group.Name()), RelativePath: group.Name(), Content: content}
results = append(results, &result{item: b, score: score})
}
}
}
sort.Slice(results, func(i, j int) bool {
return results[i].score > results[j].score
})
for _, r := range results {
ret = append(ret, r.item)
}
return
}
func DocSaveAsTemplate(id, name string, overwrite bool) (code int, err error) {
return DocSaveAsTemplateWithDatabaseMode(id, name, overwrite, TemplateDatabaseModeCopy)
}
func GetDocSaveAsTemplateInfo(id string) (ret *DocSaveAsTemplateInfo, err error) {
FlushTxQueue()
bt := treenode.GetBlockTree(id)
if nil == bt {
return nil, ErrBlockNotFound
}
tree, err := filesys.LoadTree(bt.BoxID, bt.Path, NewLute())
if nil != err {
return nil, err
}
node := tree.Root
if "d" != bt.Type {
node = treenode.GetNodeInTree(tree, id)
if nil == node {
return nil, ErrBlockNotFound
}
}
exportNodes := []*ast.Node{node}
if ast.NodeHeading == node.Type {
exportNodes = append(exportNodes, treenode.HeadingChildren(node)...)
}
hasDatabase := false
for _, exportNode := range exportNodes {
ast.Walk(exportNode, func(n *ast.Node, entering bool) ast.WalkStatus {
if entering && ast.NodeAttributeView == n.Type {
hasDatabase = true
return ast.WalkStop
}
return ast.WalkContinue
})
if hasDatabase {
break
}
}
attrs := parse.IAL2Map(tree.Root.KramdownIAL)
name := strings.TrimSpace(attrs[templateExportNameAttr])
if "" == name {
name = getNodeRefText(node)
if "" == name {
name = id
}
}
ret = &DocSaveAsTemplateInfo{
Name: name,
Directory: attrs[templateExportDirectoryAttr],
HasDatabase: hasDatabase,
}
return
}
func DocSaveAsTemplateWithDatabaseMode(id, name string, overwrite bool, databaseMode TemplateDatabaseMode) (code int, err error) {
return DocSaveAsTemplateInDirectory(id, name, "", overwrite, databaseMode)
}
func DocSaveAsTemplateInDirectoryAndRemember(id, name, directory string, overwrite bool,
databaseMode TemplateDatabaseMode) (code int, err error) {
code, err = DocSaveAsTemplateInDirectory(id, name, directory, overwrite, databaseMode)
if nil != err || 0 != code {
return
}
bt := treenode.GetBlockTree(id)
if nil == bt {
return
}
err = SetBlockAttrs(bt.RootID, map[string]string{
templateExportNameAttr: name,
templateExportDirectoryAttr: directory,
})
if nil != err {
logging.LogErrorf("remember template export settings failed: %s", err)
err = nil
}
return
}
func DocSaveAsTemplateInDirectory(id, name, directory string, overwrite bool, databaseMode TemplateDatabaseMode) (code int, err error) {
if err = validateTemplateRelativePath(directory, true); err != nil {
return
}
if databaseMode == "" {
databaseMode = TemplateDatabaseModeCopy
}
if TemplateDatabaseModeCopy != databaseMode && TemplateDatabaseModeReference != databaseMode {
return 0, fmt.Errorf("unsupported template database mode [%s]", databaseMode)
}
bt := treenode.GetBlockTree(id)
if nil == bt {
return
}
tree := prepareExportTree(bt)
tree.Root.RemoveIALAttr(templateExportNameAttr)
tree.Root.RemoveIALAttr(templateExportDirectoryAttr)
markTemplateAttributeViewModes(tree.Root, databaseMode)
addBlockIALNodes(tree, true)
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering {
return ast.WalkContinue
}
// Content in templates is not properly escaped
// https://github.com/siyuan-note/siyuan/issues/9649
// https://github.com/siyuan-note/siyuan/issues/13701
switch n.Type {
case ast.NodeCodeBlockCode:
n.Tokens = bytes.ReplaceAll(n.Tokens, []byte("""), []byte("\""))
case ast.NodeCodeSpanContent:
n.Tokens = bytes.ReplaceAll(n.Tokens, []byte("""), []byte("\""))
case ast.NodeBlockQueryEmbedScript:
n.Tokens = bytes.ReplaceAll(n.Tokens, []byte("""), []byte("\""))
case ast.NodeTextMark:
if n.IsTextMarkType("code") {
n.TextMarkTextContent = strings.ReplaceAll(n.TextMarkTextContent, """, "\"")
}
}
return ast.WalkContinue
})
var unlinks []*ast.Node
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering {
return ast.WalkContinue
}
if ast.NodeCodeBlockFenceInfoMarker == n.Type {
if lang := string(n.CodeBlockInfo); "siyuan-template" == lang || "template" == lang {
if n.Parent.Parent == tree.Root {
if attrs := templateDocumentAttributes(n.Next.Tokens); len(attrs) > 0 {
n.CodeBlockInfo = []byte(templateDocumentAttributeMarker)
n.Parent.KramdownIAL = nil
if next := n.Parent.Next; next != nil && next.Type == ast.NodeKramdownBlockIAL {
unlinks = append(unlinks, next)
}
return ast.WalkContinue
}
}
// 将模板代码转换为段落文本 https://github.com/siyuan-note/siyuan/pull/15345
unlinks = append(unlinks, n.Parent)
p := treenode.NewParagraph(n.Parent.ID)
// 代码块内可能会有多个空行,但是这里不需要分块处理,后面渲染一个文本节点即可
p.AppendChild(&ast.Node{Type: ast.NodeText, Tokens: n.Next.Tokens})
n.Parent.InsertBefore(p)
}
}
return ast.WalkContinue
})
for _, n := range unlinks {
n.Unlink()
}
luteEngine := NewLute()
formatRenderer := render.NewFormatRenderer(tree, luteEngine.RenderOptions, luteEngine.ParseOptions)
md := formatRenderer.Render()
// 单独渲染根节点的 IAL
if 0 < len(tree.Root.KramdownIAL) {
// 把 docIAL 中的 id 调整到第一个
tree.Root.RemoveIALAttr("id")
tree.Root.KramdownIAL = append([][]string{{"id", tree.Root.ID}}, tree.Root.KramdownIAL...)
md = append(md, []byte("\n")...)
md = append(md, parse.IAL2Tokens(tree.Root.KramdownIAL)...)
}
name = util.FilterFileName(name) + ".md"
name = util.TruncateLenFileName(name)
templateFileLock.Lock()
defer templateFileLock.Unlock()
root, err := openTemplateRoot()
if err != nil {
return 0, err
}
defer root.Close()
relativePath := path.Join(directory, name)
if err = checkTemplateFilePath(root, relativePath); err != nil {
return 0, err
}
abs := filepath.Join(root.Name(), filepath.FromSlash(relativePath))
filelock.Lock(abs)
defer filelock.Unlock(abs)
_, statErr := root.Stat(relativePath)
if statErr == nil {
if !overwrite {
code = 1
return
}
} else if !errors.Is(statErr, os.ErrNotExist) {
return 0, statErr
}
err = writeTemplateSource(root, relativePath, string(md), errors.Is(statErr, os.ErrNotExist))
if err == nil {
IncSyncIfNeeded(abs)
}
return
}
func markTemplateAttributeViewModes(root *ast.Node, databaseMode TemplateDatabaseMode) {
if nil == root {
return
}
ast.Walk(root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering || ast.NodeAttributeView != n.Type {
return ast.WalkContinue
}
if TemplateDatabaseModeReference == databaseMode {
n.SetIALAttr(templateDatabaseModeAttr, string(databaseMode))
} else {
n.RemoveIALAttr(templateDatabaseModeAttr)
}
return ast.WalkContinue
})
}
// 动态图标模板的源码与渲染输出上限。图标文本的实际需要远小于这两个值,
// 上限用于阻断调用方用少量输入换取大量分配的模板写法。
const (
maxDynamicIconTemplateSourceSize = 8 * 1024
maxDynamicIconTemplateOutputSize = 8 * 1024
)
// RenderDynamicIconContentTemplate 渲染动态图标中的模板内容。
// 调用方必须自行完成授权:只读角色会失去按块 ID 读取工作区数据的模板函数,
// 并且模板源码只能取自工作区中已保存的图标属性,避免绕过发布访问控制。
func RenderDynamicIconContentTemplate(c *gin.Context, content, id string) (ret string) {
tree, err := LoadTreeByBlockID(id)
if err != nil {
return
}
node := treenode.GetNodeInTree(tree, id)
if nil == node {
return
}
if IsReadOnlyRoleContext(c) {
// 只读调用方不能自带模板源码,源码只能来自工作区中已保存的图标属性,
// 否则任意发布读者都能提交自选模板,借模板函数把少量请求放大成大量分配
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-cxwr-r7cq-xw52
if content = savedDynamicIconContent(node); "" == content {
return
}
}
if maxDynamicIconTemplateSourceSize < len(content) {
logging.LogWarnf("dynamic icon template source exceeds %d bytes, id [%s]", maxDynamicIconTemplateSourceSize, id)
return
}
block := sql.BuildBlockFromNode(node, tree)
if nil == block {
return
}
dataModel := map[string]string{}
title := block.Name
if "d" == block.Type {
title = block.Content
}
dataModel["title"] = title
dataModel["id"] = block.ID
dataModel["name"] = block.Name
dataModel["alias"] = block.Alias
goTpl := template.New("").Delims(".action{", "}")
tplFuncMap := dynamicIconTemplateFuncs(c)
goTpl = goTpl.Funcs(tplFuncMap)
tpl, err := goTpl.Parse(content)
if err != nil {
err = fmt.Errorf(Conf.Language(44), err.Error())
return
}
buf := newLimitedBuffer(maxDynamicIconTemplateOutputSize)
if err = tpl.Execute(buf, dataModel); err != nil {
err = fmt.Errorf(Conf.Language(44), err.Error())
return
}
if buf.Truncated() {
// 输出超过上限说明模板把输入放大成了不合理的文本,按不可渲染处理
logging.LogWarnf("dynamic icon template output exceeds %d bytes, id [%s]", maxDynamicIconTemplateOutputSize, id)
return
}
ret = buf.String()
return
}
// savedDynamicIconContent 从块已保存的图标属性中取出动态图标的 content 参数。
// 只读调用方的模板源码只能来自这里,请求中的 content 不参与模板渲染。
func savedDynamicIconContent(node *ast.Node) (ret string) {
icon := strings.TrimSpace(util.UnescapeHTML(node.IALAttr("icon")))
if !strings.HasPrefix(icon, "api/icon/getDynamicIcon") {
return
}
u, err := url.Parse(icon)
if nil != err {
return
}
return u.Query().Get("content")
}
// limitedBuffer 在累计写入超过 limit 后丢弃后续内容并标记截断,避免模板输出无上限增长。
// Write 对超出部分返回成功,使模板继续渲染而不是报错,由调用方按截断处理。
type limitedBuffer struct {
buf bytes.Buffer
limit int
truncated bool
}
func newLimitedBuffer(limit int) (ret *limitedBuffer) {
ret = &limitedBuffer{limit: limit}
ret.buf.Grow(4096)
return
}
func (b *limitedBuffer) Write(p []byte) (n int, err error) {
if remaining := b.limit - b.buf.Len(); len(p) > remaining {
if 0 < remaining {
b.buf.Write(p[:remaining])
}
b.truncated = true
return len(p), nil
}
return b.buf.Write(p)
}
func (b *limitedBuffer) Truncated() bool { return b.truncated }
func (b *limitedBuffer) String() string { return b.buf.String() }
// dynamicIconTemplateFuncNames 是动态图标模板允许使用的函数白名单。
// 这里用白名单而不是从通用模板函数中逐个删除:图标模板只需要字符串、日期与数值格式化,
// 不需要 until、repeat、randBytes 等能把少量输入放大成大量分配的函数,
// 也不需要 bcrypt、htpasswd、derivePassword 等慢速 KDF;
// 删除清单无法覆盖 sprig 后续版本新增的函数,白名单对新增函数默认拒绝。
// 白名单内不放任何构造列表的函数(list、tuple、splitList 等),
// 这样模板里的 range 只能遍历 4 项数据模型,无法把 printf 这类内建函数放大成循环。
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-cxwr-r7cq-xw52
var dynamicIconTemplateFuncNames = []string{
// 字符串处理
"trim", "trimAll", "trimSuffix", "trimPrefix", "upper", "lower", "title", "untitle",
"substr", "trunc", "abbrev", "abbrevboth", "initials", "nospace", "swapcase", "snakecase",
"camelcase", "kebabcase", "contains", "hasPrefix", "hasSuffix", "quote", "squote", "cat",
"replace", "plural", "toString",
// 日期时间
"now", "date", "dateInZone", "dateModify", "duration", "durationRound", "unixEpoch", "toDate",
"Weekday", "WeekdayCN", "WeekdayCN2", "ISOWeek", "ISOYear", "ISOMonth", "ISOWeekDate", "parseTime",
// 数值
"add", "add1", "sub", "mul", "div", "mod", "max", "min", "floor", "ceil", "round",
"addf", "subf", "mulf", "divf", "maxf", "minf", "FormatFloat", "pow", "powf", "log", "logf",
// 取值与转换
"default", "empty", "coalesce", "ternary", "atoi", "int", "int64", "float64",
// 工作区数据,按角色另行放行
"getHPathByID", "statBlock", "runeCount", "wordCount", "countif", "markdown2text", "markdown2content",
}
// dynamicIconTemplateFuncs 返回动态图标模板可用的函数表。
// 模板按块 ID 直接读取工作区数据,与动态图标模板自身的授权无关,
// 因此只读角色(发布读者与匿名访问者)必须剔除这些函数,防止其绕过发布访问控制读取被禁用、
// 受密码保护或加密笔记本中的文档元数据与块统计。
func dynamicIconTemplateFuncs(c *gin.Context) (ret template.FuncMap) {
all := filesys.BuiltInTemplateFuncs()
ret = make(template.FuncMap, len(dynamicIconTemplateFuncNames))
for _, name := range dynamicIconTemplateFuncNames {
if fn, ok := all[name]; ok {
ret[name] = fn
}
}
if IsReadOnlyRoleContext(c) {
delete(ret, "getHPathByID")
delete(ret, "statBlock")
}
return
}
func RenderTemplate(p, id string, preview bool) (tree *parse.Tree, dom string, err error) {
mode := TemplateRenderModeContent
if preview {
mode = TemplateRenderModePreview
}
tree, dom, _, err = RenderTemplateWithMode(p, id, mode)
return
}
type templateAttributeViewPlan struct {
mode TemplateDatabaseMode
source *av.AttributeView
target *av.AttributeView
selectedView *av.View
copiedViewIDs map[string]string
}
type templateAttributeViewCopy struct {
target *av.AttributeView
copiedViewIDs map[string]string
}
func templateAttributeViewBoxID(tree *parse.Tree) string {
if nil != tree && IsEncryptedBox(tree.Box) {
return tree.Box
}
return ""
}
func templateAttributeViewMode(node *ast.Node) (ret TemplateDatabaseMode, err error) {
value := strings.TrimSpace(node.IALAttr(templateDatabaseModeAttr))
if "" == value {
return TemplateDatabaseModeCopy, nil
}
ret = TemplateDatabaseMode(value)
if TemplateDatabaseModeCopy != ret && TemplateDatabaseModeReference != ret {
return "", fmt.Errorf("unsupported template database mode [%s]", value)
}
return
}
func validateTemplateAttributeViewNode(node *ast.Node, attrView *av.AttributeView) (selectedView *av.View, err error) {
viewID := strings.TrimSpace(node.IALAttr(av.NodeAttrView))
if "" != viewID {
selectedView = attrView.GetView(viewID)
if nil == selectedView {
return nil, fmt.Errorf("attribute view [%s] view [%s] not found", attrView.ID, viewID)
}
} else if selectedView, err = attrView.GetFirstView(); nil != err {
return nil, fmt.Errorf("attribute view [%s] has no available view: %w", attrView.ID, err)
}
visibleViewIDs := strings.TrimSpace(node.IALAttr(av.NodeAttrVisibleViewIDs))
if "" == visibleViewIDs {
return
}
visibleViewCount := 0
for visibleViewID := range strings.SplitSeq(visibleViewIDs, ",") {
visibleViewID = strings.TrimSpace(visibleViewID)
if "" == visibleViewID {
continue
}
visibleViewCount++
if nil == attrView.GetView(visibleViewID) {
return nil, fmt.Errorf("attribute view [%s] visible view [%s] not found", attrView.ID, visibleViewID)
}
}
if 1 > visibleViewCount {
return nil, fmt.Errorf("attribute view [%s] has no available visible view", attrView.ID)
}
return
}
func resolveCopyTemplateAttributeView(node *ast.Node, attrView *av.AttributeView) *av.View {
if viewID := strings.TrimSpace(node.IALAttr(av.NodeAttrView)); "" != viewID {
if view := attrView.GetView(viewID); nil != view {
return view
}
}
view, _ := attrView.GetFirstView()
return view
}
func copyTemplateAttributeView(source *av.AttributeView) (ret *templateAttributeViewCopy, err error) {
target := source.Clone()
if nil == target {
return nil, fmt.Errorf("clone attribute view [%s] failed", source.ID)
}
if len(source.Views) != len(target.Views) {
return nil, fmt.Errorf("clone attribute view [%s] views failed", source.ID)
}
copiedViewIDs := map[string]string{}
for i, sourceView := range source.Views {
if nil == sourceView || nil == target.Views[i] {
return nil, fmt.Errorf("clone attribute view [%s] view failed", source.ID)
}
copiedViewIDs[sourceView.ID] = target.Views[i].ID
}
return &templateAttributeViewCopy{target: target, copiedViewIDs: copiedViewIDs}, nil
}
func prepareTemplateAttributeViews(tree *parse.Tree, preview bool) (plans map[*ast.Node]*templateAttributeViewPlan,
copies []*templateAttributeViewCopy, err error) {
plans = map[*ast.Node]*templateAttributeViewPlan{}
referenceSources := map[string]*av.AttributeView{}
copySources := map[string]*av.AttributeView{}
copyBySourceID := map[string]*templateAttributeViewCopy{}
boxID := templateAttributeViewBoxID(tree)
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering || ast.NodeAttributeView != n.Type {
return ast.WalkContinue
}
mode, modeErr := templateAttributeViewMode(n)
if nil != modeErr {
err = modeErr
return ast.WalkStop
}
if TemplateDatabaseModeReference == mode {
source := referenceSources[n.AttributeViewID]
if nil == source {
source, modeErr = av.ParseAttributeViewInBox(n.AttributeViewID, boxID)
if nil != modeErr {
err = fmt.Errorf("parse attribute view [%s] in box [%s] failed: %w", n.AttributeViewID, boxID, modeErr)
return ast.WalkStop
}
if nil == source || source.ID != n.AttributeViewID {
err = fmt.Errorf("attribute view [%s] not found in box [%s]", n.AttributeViewID, boxID)
return ast.WalkStop
}
referenceSources[n.AttributeViewID] = source
}
selectedView, validateErr := validateTemplateAttributeViewNode(n, source)
if nil != validateErr {
err = validateErr
return ast.WalkStop
}
plans[n] = &templateAttributeViewPlan{
mode: mode, source: source, target: source, selectedView: selectedView,
}
return ast.WalkContinue
}
source := copySources[n.AttributeViewID]
if nil == source {
source, modeErr = av.ParseAttributeView(n.AttributeViewID)
if nil != modeErr || nil == source {
if nil == modeErr {
modeErr = av.ErrViewNotFound
}
logging.LogErrorf("parse attribute view [%s] failed: %s", n.AttributeViewID, modeErr)
plans[n] = &templateAttributeViewPlan{mode: mode}
return ast.WalkContinue
}
copySources[n.AttributeViewID] = source
}
selectedView := resolveCopyTemplateAttributeView(n, source)
plan := &templateAttributeViewPlan{mode: mode, source: source, target: source, selectedView: selectedView}
if !preview {
copied := copyBySourceID[source.ID]
if nil == copied {
copied, err = copyTemplateAttributeView(source)
if nil != err {
logging.LogErrorf("%s", err)
err = nil
plans[n] = &templateAttributeViewPlan{mode: mode}
return ast.WalkContinue
}
copyBySourceID[source.ID] = copied
copies = append(copies, copied)
}
plan.target = copied.target
plan.copiedViewIDs = copied.copiedViewIDs
}
plans[n] = plan
return ast.WalkContinue
})
return
}
func saveTemplateAttributeViewCopies(copies []*templateAttributeViewCopy, boxID string) error {
for _, copied := range copies {
if "" != boxID {
av.SetAVBoxID(copied.target.ID, boxID)
}
err := av.SaveAttributeView(copied.target)
if "" != boxID {
av.SetAVBoxID(copied.target.ID, "")
}
if nil != err {
return fmt.Errorf("save attribute view [%s] failed: %w", copied.target.ID, err)
}
}
return nil
}
func applyTemplateAttributeViewPlan(node *ast.Node, plan *templateAttributeViewPlan) (*av.View, error) {
node.RemoveIALAttr(templateDatabaseModeAttr)
if TemplateDatabaseModeCopy == plan.mode {
// 完整复制会断开关联字段,实例上下文筛选不再有有效的目标数据库。
node.RemoveIALAttr(av.NodeAttrContextFilter)
}
if nil == plan.source || nil == plan.target || nil == plan.selectedView {
return nil, nil
}
node.AttributeViewID = plan.target.ID
viewID := plan.selectedView.ID
if TemplateDatabaseModeCopy == plan.mode && nil != plan.copiedViewIDs {
viewID = plan.copiedViewIDs[viewID]
if "" == viewID {
return nil, fmt.Errorf("copied attribute view [%s] view mapping not found", plan.source.ID)
}
if sourceViewID := strings.TrimSpace(node.IALAttr(av.NodeAttrView)); "" != sourceViewID {
if copiedViewID := plan.copiedViewIDs[sourceViewID]; "" != copiedViewID {
node.SetIALAttr(av.NodeAttrView, copiedViewID)
} else {
node.RemoveIALAttr(av.NodeAttrView)
}
}
if visibleViewIDs := strings.TrimSpace(node.IALAttr(av.NodeAttrVisibleViewIDs)); "" != visibleViewIDs {
var copiedVisibleViewIDs []string
for sourceViewID := range strings.SplitSeq(visibleViewIDs, ",") {
sourceViewID = strings.TrimSpace(sourceViewID)
if copiedViewID := plan.copiedViewIDs[sourceViewID]; "" != copiedViewID {
copiedVisibleViewIDs = append(copiedVisibleViewIDs, copiedViewID)
}
}
if 0 < len(copiedVisibleViewIDs) {
node.SetIALAttr(av.NodeAttrVisibleViewIDs, strings.Join(copiedVisibleViewIDs, ","))
} else {
node.RemoveIALAttr(av.NodeAttrVisibleViewIDs)
}
}
}
view := plan.target.GetView(viewID)
if nil == view {
return nil, fmt.Errorf("attribute view [%s] view [%s] not found", plan.target.ID, viewID)
}
node.AttributeViewType = string(view.LayoutType)
return view, nil
}
func templateAttributeViewPreviewTable(node *ast.Node, plan *templateAttributeViewPlan) *ast.Node {
view := *plan.selectedView
if nil != plan.selectedView.Calendar {
calendar := *plan.selectedView.Calendar
table := *calendar.LayoutTable
table.Columns = append([]*av.ViewTableColumn(nil), table.Columns...)
calendar.LayoutTable = &table
view.Calendar = &calendar
}
if nil != plan.selectedView.List {
list := *plan.selectedView.List
list.Columns = append([]*av.ViewTableColumn(nil), plan.selectedView.List.Columns...)
view.List = &list
}
if nil != plan.selectedView.Table {
table := *plan.selectedView.Table
table.Columns = append([]*av.ViewTableColumn(nil), plan.selectedView.Table.Columns...)
view.Table = &table
}
var table *av.Table
if TemplateDatabaseModeReference == plan.mode {
// 引用数据库模板的预览只显示结构和表头,避免在预览中暴露被引用数据库的数据。
switch view.LayoutType {
case av.LayoutTypeGallery:
view.Table = av.NewLayoutTable()
for _, field := range view.Gallery.CardFields {
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
}
case av.LayoutTypeKanban:
view.Table = av.NewLayoutTable()
for _, field := range view.Kanban.Fields {
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
}
}
depth := 1
table = sql.RenderAttributeViewTable(plan.source, &view, "", &depth, map[string]*av.AttributeView{}, true)
table.Rows = nil
table.RowCount = 0
} else {
table = getAttrViewTable(plan.source, &view, "")
}
aligns := getAttrViewTableAligns(table, false)
mdTable := &ast.Node{Type: ast.NodeTable, TableAligns: aligns}
mdTableHead := &ast.Node{Type: ast.NodeTableHead}
mdTable.AppendChild(mdTableHead)
mdTableHeadRow := &ast.Node{Type: ast.NodeTableRow, TableAligns: aligns}
mdTableHead.AppendChild(mdTableHeadRow)
for index, col := range table.Columns {
cell := &ast.Node{Type: ast.NodeTableCell, TableCellAlign: aligns[index]}
cell.AppendChild(&ast.Node{Type: ast.NodeText, Tokens: []byte(col.Name)})
mdTableHeadRow.AppendChild(cell)
}
node.InsertBefore(mdTable)
return mdTable
}
func RenderTemplateWithMode(p, id string, mode TemplateRenderMode) (tree *parse.Tree, dom string,
summary *TemplateDocTreePlanSummary, err error) {
return renderTemplateSource(p, id, mode, nil)
}
// 编辑器预览使用未保存的源码,文件路径仅用于解析同包子模板。
func PreviewTemplateSource(p, id, content string) (tree *parse.Tree, dom string, summary *TemplateDocTreePlanSummary, err error) {
if len(content) > maxTemplateSourceSize {
return nil, "", nil, errors.New("template source is too large")
}
return renderTemplateSource(p, id, TemplateRenderModePreview, &content)
}
func renderTemplateSource(p, id string, mode TemplateRenderMode, content *string) (tree *parse.Tree, dom string,
summary *TemplateDocTreePlanSummary, err error) {
return renderTemplateSourceAt(p, id, mode, content, nil)
}
func renderTemplateSourceAt(p, id string, mode TemplateRenderMode, content *string, now *time.Time) (tree *parse.Tree, dom string,
summary *TemplateDocTreePlanSummary, err error) {
if TemplateRenderModeContent != mode && TemplateRenderModePreview != mode && TemplateRenderModeEditorInsert != mode {
err = fmt.Errorf("unsupported template render mode [%s]", mode)
return
}
preview := TemplateRenderModePreview == mode
tree, err = LoadTreeByBlockID(id)
if err != nil {
return
}
sourceTree := tree
node := treenode.GetNodeInTree(tree, id)
if nil == node {
err = ErrBlockNotFound
return
}
block := sql.BuildBlockFromNode(node, tree)
var md []byte
if content == nil {
md, err = os.ReadFile(p)
if err != nil {
return
}
} else {
md = []byte(*content)
}
dataModel := map[string]string{}
var titleVar string
if nil != block {
titleVar = block.Name
if "d" == block.Type {
titleVar = block.Content
}
dataModel["title"] = titleVar
dataModel["id"] = block.ID
dataModel["name"] = block.Name
dataModel["alias"] = block.Alias
dataModel["rootID"] = sourceTree.Root.ID
dataModel["hPath"] = sourceTree.HPath
if parentDir := path.Dir(sourceTree.Path); "/" != parentDir && "." != parentDir {
dataModel["parentID"] = path.Base(parentDir)
} else {
dataModel["parentID"] = ""
}
}
collector := &templateDocTreeCollector{
rootID: sourceTree.Root.ID,
boxID: sourceTree.Box,
rootPath: sourceTree.Path,
rootHPath: sourceTree.HPath,
templatePath: p,
enabled: TemplateRenderModePreview == mode || TemplateRenderModeEditorInsert == mode,
allowCreation: TemplateRenderModePreview == mode || TemplateRenderModeEditorInsert == mode,
}
goTpl := template.New("").Delims(".action{", "}")
tplFuncMap := filesys.BuiltInTemplateFuncs()
if now != nil {
tplFuncMap["now"] = func() time.Time { return *now }
}
tplFuncMap["createDocTree"] = collector.create
tplFuncMap["renderDocRef"] = collector.renderDocRef
sql.SQLTemplateFuncs(&tplFuncMap, sourceTree.Box)
goTpl = goTpl.Funcs(tplFuncMap)
tpl, err := goTpl.Funcs(tplFuncMap).Parse(gulu.Str.FromBytes(md))
if err != nil {
err = fmt.Errorf(Conf.Language(44), err.Error())
return
}
if collector.enabled && templateUsesFunction(tpl, "createDocTree") {
if err = validateTemplateCallGraph(tpl, tpl.Name()); nil != err {
return
}
var location *treenode.DocumentPath
location, err = getDocumentPath(sourceTree.Box, sourceTree.ID)
if err != nil {
return
}
collector.rootRevision = location.Revision
}
buf := &bytes.Buffer{}
buf.Grow(4096)
if err = tpl.Execute(buf, dataModel); err != nil {
err = fmt.Errorf(Conf.Language(44), err.Error())
return
}
if 0 < len(collector.nodes) && maxTemplateDocTreeOutputSize < buf.Len() {
err = fmt.Errorf("template output exceeds %d bytes", maxTemplateDocTreeOutputSize)
return
}
collector.totalOutput = buf.Len()
md = buf.Bytes()
tree, err = parseTemplateKTree(md)
if err != nil {
logging.LogErrorf("parse template [%s] failed: %s", p, err)
return
}
tree.Box = sourceTree.Box
if 0 < len(collector.nodes) {
if err = collector.validateLocations(); nil != err {
return
}
if templateTreeContainsAttributeView(tree) {
err = errors.New("database blocks are not supported by createDocTree templates")
return
}
if err = renderTemplateDocTreeNodes(collector, tpl, tplFuncMap); nil != err {
return
}
}
attributeViewPlans, attributeViewCopies, prepareErr := prepareTemplateAttributeViews(tree, preview)
if nil != prepareErr {
err = prepareErr
return
}
var nodesNeedAppendChild, unlinks []*ast.Node
// 模板内部块旧 ID 到新 ID 的映射,用于成套改写模板内部的自引用
blockIDs := map[string]string{}
restoreTabsSelection := captureTemplateTabsSelection(tree.Root)
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering {
return ast.WalkContinue
}
if "" != n.ID {
// 根文档映射到目标文档,其他内容块生成新 ID,并记录映射用于改写模板内部引用
oldID := n.ID
if ast.NodeDocument == n.Type {
n.ID = sourceTree.Root.ID
} else {
n.ID = ast.NewNodeID()
}
blockIDs[oldID] = n.ID
n.SetIALAttr("id", n.ID)
n.RemoveIALAttr(av.NodeAttrNameAvs)
// Blocks created via template update time earlier than creation time https://github.com/siyuan-note/siyuan/issues/8607
treenode.RefreshUpdated(n)
}
if (ast.NodeListItem == n.Type && (nil == n.FirstChild ||
(3 == n.ListData.Typ && (nil == n.FirstChild.Next || ast.NodeKramdownBlockIAL == n.FirstChild.Next.Type)))) ||
(ast.NodeBlockquote == n.Type && nil != n.FirstChild && nil != n.FirstChild.Next && ast.NodeKramdownBlockIAL == n.FirstChild.Next.Type) ||
(ast.NodeCallout == n.Type && nil != n.FirstChild && ast.NodeKramdownBlockIAL == n.FirstChild.Type) {
nodesNeedAppendChild = append(nodesNeedAppendChild, n)
}
if n.IsTextMarkType("inline-math") {
if n.ParentIs(ast.NodeTableCell) {
// 表格中的公式中带有管道符时使用 HTML 实体替换管道符 Improve the handling of inline-math containing `|` in the table https://github.com/siyuan-note/siyuan/issues/9227
n.TextMarkInlineMathContent = strings.ReplaceAll(n.TextMarkInlineMathContent, "|", "|")
}
}
if ast.NodeAttributeView == n.Type {
plan := attributeViewPlans[n]
if nil == plan {
err = fmt.Errorf("attribute view [%s] template plan not found", n.AttributeViewID)
return ast.WalkStop
}
appliedView, applyErr := applyTemplateAttributeViewPlan(n, plan)
if nil != applyErr {
err = applyErr
return ast.WalkStop
}
if preview && nil != appliedView {
templateAttributeViewPreviewTable(n, plan)
unlinks = append(unlinks, n)
}
}
return ast.WalkContinue
})
if nil != err {
return
}
if !preview {
if err = saveTemplateAttributeViewCopies(attributeViewCopies, templateAttributeViewBoxID(tree)); nil != err {
return
}
}
restoreTabsSelection()
// 用映射成套改写模板内部的自引用,并补全指向外部块的引用锚文本
// 仅命中 blockIDs 的引用(模板内部块)才会改写 ID;未命中的(外部块)保持不变
treenode.WalkWithInlineTitles(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering {
return ast.WalkContinue
}
if n.IsTextMarkType("block-ref") {
defID := n.TextMarkBlockRefID
if newDefID, internal := blockIDs[defID]; internal {
// 模板内部自引用:成套改写为新 ID
n.TextMarkBlockRefID = newDefID
} else {
// 外部引用:保持 ID 不变,补全空锚文本
if refText := n.Text(); "" == refText {
if IsEncryptedBox(tree.Box) {
refText = strings.TrimSpace(GetBlockRefTextInBox(defID, tree.Box))
} else {
refText = strings.TrimSpace(sql.GetRefText(defID))
}
if "" != refText {
treenode.SetDynamicBlockRefText(n, refText)
} else {
unlinks = append(unlinks, n)
}
}
}
} else if ast.NodeBlockRef == n.Type {
// 兼容遗留块引用节点
if refID := n.ChildByType(ast.NodeBlockRefID); nil != refID {
defID := refID.TokensStr()
if newDefID, internal := blockIDs[defID]; internal {
// 模板内部自引用:成套改写为新 ID
refID.Tokens = []byte(newDefID)
} else {
// 外部引用:保持 ID 不变,补全空锚文本
if refText := n.Text(); "" == refText {
if IsEncryptedBox(tree.Box) {
refText = strings.TrimSpace(GetBlockRefTextInBox(defID, tree.Box))
} else {
refText = strings.TrimSpace(sql.GetRefText(defID))
}
if "" != refText {
treenode.SetDynamicBlockRefText(n, refText)
} else {
unlinks = append(unlinks, n)
}
}
}
}
} else if treenode.IsBlockLink(n) {
// 块超链接指向模板内部块时成套改写
defID := strings.TrimPrefix(n.TextMarkAHref, "siyuan://blocks/")
if newDefID, internal := blockIDs[defID]; internal {
n.TextMarkAHref = "siyuan://blocks/" + newDefID
}
} else if ast.NodeBlockQueryEmbedScript == n.Type {
// 嵌入块查询脚本中引用模板内部块时成套改写
for oldID, newID := range blockIDs {
n.Tokens = bytes.ReplaceAll(n.Tokens, []byte(oldID), []byte(newID))
}
}
return ast.WalkContinue
})
// 富文本单元格由源内容生成 DOM,先将引用投影中的改写同步回源。
if err = treenode.SyncTableCellRichInlineChanges(tree.Root); nil != err {
return
}
for _, n := range nodesNeedAppendChild {
if ast.NodeBlockquote == n.Type {
n.FirstChild.InsertAfter(treenode.NewParagraph(""))
} else {
n.AppendChild(treenode.NewParagraph(""))
}
}
for _, n := range unlinks {
n.Unlink()
}
if 0 < len(collector.nodes) && nil == tree.Root.FirstChild {
tree.Root.AppendChild(treenode.NewParagraph(""))
}
// 折叠标题下方块需要在模板插入后从当前 DOM 中移除,展开标题时再由内核加载,避免内容重复。
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if entering && n.IsBlock() {
treenode.ClearLegacyHeadingFold(n)
}
return ast.WalkContinue
})
for _, n := range treenode.CollectFoldHiddenNodes(tree.Root) {
n.SetIALAttr("status", "temp")
}
icon := tree.Root.IALAttr("icon")
if "" != icon {
// 动态图标需要反转义 https://github.com/siyuan-note/siyuan/issues/13211
icon = util.UnescapeHTML(icon)
tree.Root.SetIALAttr("icon", icon)
}
luteEngine := NewLute()
dom = luteEngine.Tree2BlockDOM(tree, luteEngine.RenderOptions, luteEngine.ParseOptions)
if 0 < len(collector.nodes) {
if TemplateRenderModeEditorInsert == mode {
summary = collector.storePlan()
} else {
summary = collector.summary("")
}
}
return
}
func addBlockIALNodes(tree *parse.Tree, removeUpdated bool) {
addBlockIALNodes0(tree, removeUpdated, false)
}
func addCanonicalBlockIALNodes(tree *parse.Tree, removeUpdated bool) {
addBlockIALNodes0(tree, removeUpdated, true)
}
func addBlockIALNodes0(tree *parse.Tree, removeUpdated, canonical bool) {
var blocks []*ast.Node
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering || !n.IsBlock() {
return ast.WalkContinue
}
if ast.NodeBlockQueryEmbed == n.Type {
if script := n.ChildByType(ast.NodeBlockQueryEmbedScript); nil != script {
script.Tokens = bytes.ReplaceAll(script.Tokens, []byte("\n"), []byte(" "))
}
} else if ast.NodeHTMLBlock == n.Type {
n.Tokens = bytes.TrimSpace(n.Tokens)
// 使用 <div> 包裹,否则后续解析时会识别为行级 HTML https://github.com/siyuan-note/siyuan/issues/4244
if !bytes.HasPrefix(n.Tokens, []byte("<div>")) {
n.Tokens = append([]byte("<div>\n"), n.Tokens...)
}
if !bytes.HasSuffix(n.Tokens, []byte("</div>")) {
n.Tokens = append(n.Tokens, []byte("\n</div>")...)
}
}
if removeUpdated {
n.RemoveIALAttr("updated")
}
if 0 < len(n.KramdownIAL) {
blocks = append(blocks, n)
}
return ast.WalkContinue
})
for _, block := range blocks {
ial := block.KramdownIAL
if canonical {
ial = canonicalBlockKramdownIAL(ial)
}
block.InsertAfter(&ast.Node{Type: ast.NodeKramdownBlockIAL, Tokens: parse.IAL2Tokens(ial)})
}
}
func applyDocContentTemplateAfterIndex(templatePath, docID string) error {
sql.FlushQueue()
if err := applyDocContentTemplate(templatePath, docID); nil != err {
return err
}
sql.FlushQueue()
return nil
}
func applyDocContentTemplate(templatePath, docID string) error {
return applyDocContentTemplateAt(templatePath, docID, nil)
}
func applyDocContentTemplateAt(templatePath, docID string, now *time.Time) error {
absPath, err := resolveDocContentTemplatePath(templatePath)
if nil != err {
return err
}
templateTree, templateDOM, _, err := renderTemplateSourceAt(absPath, docID, TemplateRenderModeContent, nil, now)
if nil != err {
return err
}
if "" == templateDOM {
return nil
}
FlushTxQueue()
flushLock.Lock()
defer flushLock.Unlock()
for _, queued := range takeQueuedTransactions() {
flushTx(queued)
}
bt, err := lookupBlockTreeInBox(docID, "", true)
if err != nil {
return err
}
tree, original, err := filesys.LoadTreeSnapshot(bt.BoxID, bt.Path, util.NewLute())
if nil != err {
return err
}
// 只移除新建文档的空占位段落,保留模板渲染期间已经提交的首块编辑。
if first := tree.Root.FirstChild; isDocContentTemplatePlaceholder(first) {
first.Unlink()
}
newTree := util.NewLute().BlockDOM2Tree(templateDOM)
var children []*ast.Node
for child := newTree.Root.FirstChild; nil != child; child = child.Next {
children = append(children, child)
}
for _, child := range children {
tree.Root.AppendChild(child)
}
templateIALs := parse.IAL2Map(templateTree.Root.KramdownIAL)
for key, value := range templateIALs {
if "name" == key || "alias" == key || "bookmark" == key || "memo" == key || "icon" == key ||
strings.HasPrefix(key, "custom-") {
tree.Root.SetIALAttr(key, value)
}
}
tree.Root.SetIALAttr("updated", util.CurrentTimeSecondsStr())
write := func(changed *parse.Tree) error {
size, writeErr := filesys.WriteTreeIfUnchanged(changed, original)
if writeErr != nil {
return writeErr
}
treenode.UpsertBlockTree(changed)
sql.UpsertTreeQueue(changed)
refreshDocInfoWithSize(changed, size)
return nil
}
handled, err := writeDocumentWithCollections(tree, write)
if err != nil {
return err
}
if !handled {
if err = write(tree); err != nil {
return err
}
IncSync()
}
invalidateDocumentHistory(tree.ID)
av.BatchUpsertBlockRel(tree.Root.ChildrenByType(ast.NodeAttributeView))
return nil
}
func isDocContentTemplatePlaceholder(node *ast.Node) bool {
if node == nil || node.Type != ast.NodeParagraph || node.FirstChild != nil || len(node.Tokens) != 0 {
return false
}
for _, attr := range node.KramdownIAL {
if attr[0] != "id" && attr[0] != "updated" {
return false
}
}
return true
}
func resolveDocContentTemplatePath(templatePath string) (string, error) {
templatePath = strings.TrimPrefix(filepath.ToSlash(strings.TrimSpace(templatePath)), "/")
cleanPath := filepath.Clean(filepath.FromSlash(templatePath))
if "" == cleanPath || "." == cleanPath || filepath.IsAbs(cleanPath) || ".." == cleanPath ||
strings.HasPrefix(cleanPath, ".."+string(os.PathSeparator)) {
return "", errors.New("invalid content template path")
}
templateRoot := filepath.Join(util.DataDir, "templates")
absPath := filepath.Join(templateRoot, cleanPath)
if !gulu.File.IsSubPath(templateRoot, absPath) {
return "", errors.New("content template path is outside templates directory")
}
if !filelock.IsExist(absPath) {
return "", fmt.Errorf("content template [%s] not found", templatePath)
}
realRoot, err := util.ResolveRealPath(templateRoot)
if nil != err {
return "", err
}
realPath, err := util.ResolveRealPath(absPath)
if nil != err {
return "", err
}
info, err := os.Stat(realPath)
if nil != err || !info.Mode().IsRegular() {
return "", fmt.Errorf("content template [%s] is not a regular file", templatePath)
}
if !gulu.File.IsSubPath(realRoot, realPath) {
return "", errors.New("content template path is outside templates directory")
}
return realPath, nil
}
// CreateTemplate 在 <data>/templates/ 下创建模板文件。name 不含扩展名,content 为 markdown 文本。
// overwrite=false 且文件已存在时返回 code=1(与 DocSaveAsTemplate 一致)。
func CreateTemplate(name, content string, overwrite bool) (code int, err error) {
name = util.FilterFileName(name) + ".md"
name = util.TruncateLenFileName(name)
savePath := filepath.Join(util.DataDir, "templates", name)
if filelock.IsExist(savePath) {
if !overwrite {
code = 1
return
}
}
err = filelock.WriteFile(savePath, []byte(content))
if err == nil {
IncSyncIfNeeded(savePath)
}
return
}