Merge remote-tracking branch 'origin/dev' into dev

kernel/api/template.go

@@ -85,7 +85,7 @@ func renderTemplate(c *gin.Context) {
 		preview = previewArg.(bool)
 	}
 
-	content, err := model.RenderTemplate(p, id, preview)
+	_, content, err := model.RenderTemplate(p, id, preview)
 	if nil != err {
 		ret.Code = -1
 		ret.Msg = util.EscapeHTML(err.Error())

kernel/model/file.go

@@ -1096,26 +1096,28 @@ func CreateDailyNote(boxID string) (p string, existed bool, err error) {
 		return
 	}
 
-	var dom string
+	var templateTree *parse.Tree
+	var templateDom string
 	if "" != boxConf.DailyNoteTemplatePath {
 		tplPath := filepath.Join(util.DataDir, "templates", boxConf.DailyNoteTemplatePath)
 		if !filelock.IsExist(tplPath) {
 			logging.LogWarnf("not found daily note template [%s]", tplPath)
 		} else {
-			dom, err = renderTemplate(tplPath, id, false)
-			if nil != err {
+			var renderErr error
+			templateTree, templateDom, renderErr = RenderTemplate(tplPath, id, false)
+			if nil != renderErr {
 				logging.LogWarnf("render daily note template [%s] failed: %s", boxConf.DailyNoteTemplatePath, err)
 			}
 		}
 	}
-	if "" != dom {
+	if "" != templateDom {
 		var tree *parse.Tree
 		tree, err = LoadTreeByBlockID(id)
 		if nil == err {
 			tree.Root.FirstChild.Unlink()
 
 			luteEngine := util.NewLute()
-			newTree := luteEngine.BlockDOM2Tree(dom)
+			newTree := luteEngine.BlockDOM2Tree(templateDom)
 			var children []*ast.Node
 			for c := newTree.Root.FirstChild; nil != c; c = c.Next {
 				children = append(children, c)
@@ -1123,6 +1125,15 @@ func CreateDailyNote(boxID string) (p string, existed bool, err error) {
 			for _, c := range children {
 				tree.Root.AppendChild(c)
 			}
+
+			// Creating a dailynote template supports doc attributes https://github.com/siyuan-note/siyuan/issues/10698
+			templateIALs := parse.IAL2Map(templateTree.Root.KramdownIAL)
+			for k, v := range templateIALs {
+				if "name" == k || "alias" == k || "bookmark" == k || "memo" == k || "title" == k || strings.HasPrefix(k, "custom-") {
+					tree.Root.SetIALAttr(k, v)
+				}
+			}
+
 			tree.Root.SetIALAttr("updated", util.CurrentTimeSecondsStr())
 			if err = indexWriteJSONQueue(tree); nil != err {
 				return

kernel/model/search.go

@@ -592,7 +592,7 @@ func FindReplace(keyword, replacement string, replaceTypes map[string]bool, ids
 					} else if n.IsTextMarkType("a") {
 						if replaceTypes["aText"] {
 							if 0 == method {
-								if bytes.Contains(n.Tokens, []byte(keyword)) {
+								if strings.Contains(n.TextMarkTextContent, keyword) {
 									n.TextMarkTextContent = strings.ReplaceAll(n.TextMarkTextContent, keyword, replacement)
 								}
 							} else if 3 == method {

kernel/model/storage.go

@@ -187,6 +187,10 @@ type CriterionTypes struct {
 	HtmlBlock     bool `json:"htmlBlock"`
 	EmbedBlock    bool `json:"embedBlock"`
 	DatabaseBlock bool `json:"databaseBlock"`
+	AudioBlock    bool `json:"audioBlock"`
+	VideoBlock    bool `json:"videoBlock"`
+	IFrameBlock   bool `json:"iframeBlock"`
+	WidgetBlock   bool `json:"widgetBlock"`
 }
 
 type CriterionReplaceTypes struct {

kernel/model/template.go

@@ -183,24 +183,21 @@ func DocSaveAsTemplate(id, name string, overwrite bool) (code int, err error) {
 	return
 }
 
-func RenderTemplate(p, id string, preview bool) (string, error) {
-	return renderTemplate(p, id, preview)
-}
-
-func renderTemplate(p, id string, preview bool) (string, error) {
-	tree, err := LoadTreeByBlockID(id)
+func RenderTemplate(p, id string, preview bool) (tree *parse.Tree, dom string, err error) {
+	tree, err = LoadTreeByBlockID(id)
 	if nil != err {
-		return "", err
+		return
 	}
 
 	node := treenode.GetNodeInTree(tree, id)
 	if nil == node {
-		return "", ErrBlockNotFound
+		err = ErrBlockNotFound
+		return
 	}
 	block := sql.BuildBlockFromNode(node, tree)
 	md, err := os.ReadFile(p)
 	if nil != err {
-		return "", err
+		return
 	}
 
 	dataModel := map[string]string{}
@@ -222,20 +219,23 @@ func renderTemplate(p, id string, preview bool) (string, error) {
 	goTpl = goTpl.Funcs(tplFuncMap)
 	tpl, err := goTpl.Funcs(tplFuncMap).Parse(gulu.Str.FromBytes(md))
 	if nil != err {
-		return "", errors.New(fmt.Sprintf(Conf.Language(44), err.Error()))
+		err = errors.New(fmt.Sprintf(Conf.Language(44), err.Error()))
+		return
 	}
 
 	buf := &bytes.Buffer{}
 	buf.Grow(4096)
 	if err = tpl.Execute(buf, dataModel); nil != err {
-		return "", errors.New(fmt.Sprintf(Conf.Language(44), err.Error()))
+		err = errors.New(fmt.Sprintf(Conf.Language(44), err.Error()))
+		return
 	}
 	md = buf.Bytes()
 	tree = parseKTree(md)
 	if nil == tree {
 		msg := fmt.Sprintf("parse tree [%s] failed", p)
 		logging.LogErrorf(msg)
-		return "", errors.New(msg)
+		err = errors.New(msg)
+		return
 	}
 
 	var nodesNeedAppendChild, unlinks []*ast.Node
@@ -357,8 +357,8 @@ func renderTemplate(p, id string, preview bool) (string, error) {
 	})
 
 	luteEngine := NewLute()
-	dom := luteEngine.Tree2BlockDOM(tree, luteEngine.RenderOptions)
-	return dom, nil
+	dom = luteEngine.Tree2BlockDOM(tree, luteEngine.RenderOptions)
+	return
 }
 
 func addBlockIALNodes(tree *parse.Tree, removeUpdated bool) {