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"
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"math"
"math/rand"
"os"
"path/filepath"
"slices"
"sort"
"strconv"
"strings"
"sync"
"time"
"unicode/utf8"
"github.com/88250/go-humanize"
"github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/88250/lute/parse"
"github.com/gin-gonic/gin"
"github.com/jinzhu/copier"
"github.com/siyuan-note/filelock"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/cache"
"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"
)
func ValidateUnusedAttributeView(id string) error {
if !ast.IsNodeIDPattern(id) {
return fmt.Errorf("invalid attribute view ID: %s", id)
}
items, err := UnusedAttributeViews(false)
if err != nil {
return err
}
for _, item := range items {
if item.Item == id {
return nil
}
}
return fmt.Errorf("attribute view is not unused: %s", id)
}
func RemoveUnusedAttributeView(id string) (err error) {
// 防御性校验:ID 必须是合法的节点 ID 格式,防止通过路径穿越读取或删除任意文件
if err = ValidateUnusedAttributeView(id); err != nil {
return
}
base := filepath.Join(util.DataDir, "storage", "av")
absPath := filepath.Join(base, id+".json")
if !filelock.IsExist(absPath) {
return fmt.Errorf("attribute view not found: %s", id)
}
historyDir, err := getHistoryDir(HistoryOpClean)
if err != nil {
logging.LogErrorf("get history dir failed: %s", err)
return
}
newP := strings.TrimPrefix(absPath, util.DataDir)
historyPath := filepath.Join(historyDir, newP)
if filelock.IsExist(absPath) {
if err = filelock.Copy(absPath, historyPath); err != nil {
return
}
}
if err = filelock.RemoveWithoutFatal(absPath); err != nil {
logging.LogErrorf("remove unused asset [%s] failed: %s", absPath, err)
util.PushErrMsg(fmt.Sprintf("%s", err), 7000)
return
}
GlobalUndoLog.ClearAttributeView(id)
IncSync()
indexHistoryDir(filepath.Base(historyDir), util.NewLute())
return
}
func RemoveUnusedAttributeViews() (ret []string, err error) {
ret = []string{}
unusedAttributeViews, err := UnusedAttributeViews(false)
if err != nil {
return
}
var size int64
msgId := util.PushMsg(Conf.Language(100), 30*1000)
defer func() {
if err != nil {
util.PushUpdateMsg(msgId, err.Error(), 7000)
return
}
msg := fmt.Sprintf(Conf.Language(280), len(ret), humanize.BytesCustomCeil(uint64(size), 2))
util.PushUpdateMsg(msgId, msg, 7000)
}()
historyDir, err := getHistoryDir(HistoryOpClean)
if err != nil {
logging.LogErrorf("get history dir failed: %s", err)
return
}
for _, unusedAv := range unusedAttributeViews {
id := unusedAv.Item
srcPath := filepath.Join(util.DataDir, "storage", "av", id+".json")
if filelock.IsExist(srcPath) {
historyPath := filepath.Join(historyDir, "storage", "av", id+".json")
if err = filelock.Copy(srcPath, historyPath); err != nil {
return
}
}
}
for _, unusedAv := range unusedAttributeViews {
id := unusedAv.Item
absPath := filepath.Join(util.DataDir, "storage", "av", id+".json")
if filelock.IsExist(absPath) {
info, statErr := os.Stat(absPath)
if statErr == nil {
size += info.Size()
}
if removeErr := filelock.RemoveWithoutFatal(absPath); removeErr != nil {
err = removeErr
logging.LogErrorf("remove unused av [%s] failed: %s", absPath, removeErr)
util.PushErrMsg(fmt.Sprintf("%s", removeErr), 7000)
return
}
GlobalUndoLog.ClearAttributeView(id)
}
ret = append(ret, absPath)
}
if 0 < len(ret) {
IncSync()
}
indexHistoryDir(filepath.Base(historyDir), util.NewLute())
return
}
func UnusedAttributeViews(sorted bool) (ret []*UnusedItem, err error) {
defer func() {
if recovered := recover(); recovered != nil {
ret = nil
err = fmt.Errorf("scan database references failed: %v", recovered)
logging.LogErrorf("%s", err)
}
}()
ret = []*UnusedItem{}
allAvIDs, err := getAllAvIDs()
if err != nil {
if os.IsNotExist(err) {
return ret, nil
}
return
}
docReferencedAvIDs := map[string]bool{}
luteEngine := util.NewLute()
boxes := Conf.GetBoxes()
for _, box := range boxes {
if IsEncryptedBox(box.ID) {
continue
}
pages, walkErr := pagedPathsWithError(filepath.Join(util.DataDir, box.ID), 32)
if walkErr != nil {
return nil, walkErr
}
for _, paths := range pages {
var trees []*parse.Tree
for _, localPath := range paths {
tree, loadTreeErr := loadTree(localPath, luteEngine)
if nil != loadTreeErr {
return nil, fmt.Errorf("read database references [%s] failed: %w", localPath, loadTreeErr)
}
trees = append(trees, tree)
}
for _, tree := range trees {
for _, id := range getAvIDs(tree, allAvIDs) {
docReferencedAvIDs[id] = true
}
}
}
}
templateAvIDs := search.FindAllMatchedTargets(filepath.Join(util.DataDir, "templates"), allAvIDs)
for _, id := range templateAvIDs {
docReferencedAvIDs[id] = true
}
checkedAvIDs := map[string]bool{}
for _, id := range allAvIDs {
if docReferencedAvIDs[id] {
continue
}
referenced, scanErr := isRelatedSrcAvDocReferenced(id, docReferencedAvIDs, checkedAvIDs)
if scanErr != nil {
return nil, scanErr
}
if !referenced {
name, _ := av.GetAttributeViewName(id)
var modTime time.Time
if sorted {
p := filepath.Join(util.DataDir, "storage", "av", id+".json")
if info, statErr := os.Stat(p); nil == statErr {
modTime = info.ModTime()
}
}
ret = append(ret, &UnusedItem{Item: id, Name: name, ModTime: modTime})
}
}
if sorted {
sort.Slice(ret, func(i, j int) bool {
if !ret[i].ModTime.Equal(ret[j].ModTime) {
return ret[i].ModTime.After(ret[j].ModTime)
}
return ret[i].Item > ret[j].Item
})
}
return
}
func isRelatedSrcAvDocReferenced(destAvID string, docReferencedAvIDs, checkedAvIDs map[string]bool) (bool, error) {
if checkedAvIDs[destAvID] {
if docReferencedAvIDs[destAvID] {
return true, nil
}
return false, nil
}
checkedAvIDs[destAvID] = true
srcAvIDs, err := av.GetSrcAvIDsWithErr(destAvID)
if err != nil {
return false, fmt.Errorf("read database relations [%s] failed: %w", destAvID, err)
}
srcAvIDs = gulu.Str.RemoveElem(srcAvIDs, destAvID) // 忽略自身关联
if 1 > len(srcAvIDs) {
return false, nil
}
for _, srcAvID := range srcAvIDs {
if docReferencedAvIDs[srcAvID] {
return true, nil
}
}
// 递归检查间接关联的 av
for _, srcAvID := range srcAvIDs {
referenced, err := isRelatedSrcAvDocReferenced(srcAvID, docReferencedAvIDs, checkedAvIDs)
if err != nil || referenced {
return referenced, err
}
}
return false, nil
}
func getAvIDs(tree *parse.Tree, allAvIDs []string) (ret []string) {
ast.Walk(tree.Root, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering {
return ast.WalkContinue
}
if ast.NodeAttributeView == n.Type {
ret = append(ret, n.AttributeViewID)
}
for _, kv := range n.KramdownIAL {
ids := util.GetContainsSubStrs(kv[1], allAvIDs)
if 0 < len(ids) {
ret = append(ret, ids...)
}
}
return ast.WalkContinue
})
ret = gulu.Str.RemoveDuplicatedElem(ret)
return
}
func getAllAvIDs() (ret []string, err error) {
ret = []string{}
// 只扫全局 AV 目录。加密笔记本的 AV 存在笔记本级目录(密文),不参与全局枚举——
// 未引用清理功能在加密笔记本锁定时无法确认引用关系(loadTree 失败),枚举加密 AV 有误删风险
entries, err := os.ReadDir(filepath.Join(util.DataDir, "storage", "av"))
if nil != err {
return
}
for _, entry := range entries {
name := entry.Name()
if !strings.HasSuffix(name, ".json") {
continue
}
id := strings.TrimSuffix(name, ".json")
if !ast.IsNodeIDPattern(id) {
continue
}
ret = append(ret, id)
}
ret = gulu.Str.RemoveDuplicatedElem(ret)
return
}
func GetAttributeViewItemIDs(avID string, blockIDs []string) (ret map[string]string) {
ret = map[string]string{}
for _, blockID := range blockIDs {
ret[blockID] = ""
}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
blockKv := attrView.GetBlockKeyValues()
for _, b := range blockKv.Values {
if _, ok := ret[b.Block.ID]; ok {
ret[b.Block.ID] = b.BlockID
}
}
return
}
func GetAttributeViewBoundBlockIDs(avID string, itemIDs []string) (ret map[string]string) {
ret = map[string]string{}
for _, itemID := range itemIDs {
ret[itemID] = ""
}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
blockKv := attrView.GetBlockKeyValues()
for _, b := range blockKv.Values {
if _, ok := ret[b.BlockID]; ok {
ret[b.BlockID] = b.Block.ID
}
}
return
}
func GetAttrViewAddingBlockDefaultValues(avID, blockID, viewID, groupID, previousBlockID, addingBlockID string) (ret map[string]*av.Value, err error) {
ret = map[string]*av.Value{}
attrView, err := avParseView(avID, blockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
view, err := resolveAttributeViewView(attrView, viewID, "", blockID)
if nil == view {
logging.LogErrorf("view [%s] not found in attribute view [%s]", viewID, avID)
return
}
filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, blockID)
if nil != contextErr {
err = contextErr
return
}
if nil != filterContext && 1 > len(filterContext.CurrentDocumentItemIDs) {
err = av.ErrAttributeViewContextNotBound
return
}
useGroupDefault := "" != groupID
if 1 > len(view.Filters) && !useGroupDefault && nil == filterContext {
// 没有过滤条件也没有分组条件时忽略
return
}
groupView := view
if useGroupDefault {
groupView = view.GetGroupByID(groupID)
}
if nil == groupView {
logging.LogErrorf("group [%s] not found in view [%s] of attribute view [%s]", groupID, viewID, avID)
return
}
ret = getAttrViewAddingBlockDefaultValues(attrView, view, groupView, previousBlockID, addingBlockID, true,
useGroupDefault, filterContext)
for _, value := range ret {
// 主键都不返回内容,避免闪烁 https://github.com/siyuan-note/siyuan/issues/15561#issuecomment-3184746195
if av.KeyTypeBlock == value.Type {
value.Block.Content = ""
}
}
return
}
func newAttrViewValueSelect(option *av.SelectOption) *av.ValueSelect {
ret := &av.ValueSelect{Content: option.Name, Color: option.Color}
if nil != option.ResolvedColor {
resolved := *option.ResolvedColor
ret.ResolvedColor = &resolved
}
return ret
}
func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, groupView *av.View, previousItemID,
addingItemID string, isCreate, useGroupDefault bool, filterContexts ...*av.FilterContext) (ret map[string]*av.Value) {
ret = map[string]*av.Value{}
filterContext := firstAttributeViewFilterContext(filterContexts)
defer func() {
applyAttributeViewContextFilterDefaultValue(attrView, addingItemID, filterContext, ret)
for keyID, value := range ret {
key, _ := attrView.GetKey(keyID)
normalizeAttrViewAddingDefaultValue(key, value)
attrView.ResolveValueSelectColors(value)
}
}()
if 1 > len(view.Filters) && !useGroupDefault && nil == filterContext {
// 没有过滤条件也没有分组条件时忽略
return
}
nearItem := getNearItem(attrView, view, groupView, previousItemID, filterContext)
// 使用模板或汇总进行过滤或分组时,需要解析涉及到的其他字段
templateRelevantKeys, rollupRelevantKeys := map[string][]*av.Key{}, map[string]*av.Key{}
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeTemplate == keyValues.Key.Type {
if tplRelevantKeys := sql.GetTemplateKeyRelevantKeys(attrView, keyValues.Key); 0 < len(tplRelevantKeys) {
for _, k := range tplRelevantKeys {
templateRelevantKeys[keyValues.Key.ID] = append(templateRelevantKeys[keyValues.Key.ID], k)
}
}
} else if av.KeyTypeRollup == keyValues.Key.Type {
if nil != keyValues.Key.Rollup {
relKey, _ := attrView.GetKey(keyValues.Key.Rollup.RelationKeyID)
if nil != relKey && nil != relKey.Relation {
if attrView.ID == relKey.Relation.AvID {
if k, _ := attrView.GetKey(keyValues.Key.Rollup.KeyID); nil != k {
rollupRelevantKeys[k.ID] = k
}
}
}
}
}
}
filterKeyIDs := map[string]bool{}
if applyFilterDefaultValues(view.Filters, attrView, addingItemID, nearItem, templateRelevantKeys, rollupRelevantKeys,
ret, filterKeyIDs) {
// 遇到 mAsset 过滤即结束全部默认值计算(保留原外层 return 语义)
return
}
if !useGroupDefault {
return
}
if nil != view.Group && av.ValueSourceRendered == view.Group.ValueSource {
// 模板渲染结果无法反向推导分组字段的存储值。
return
}
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
return
}
keyValues, _ := attrView.GetKeyValues(groupKey.ID)
if nil == keyValues {
return
}
newValue := getNewValueByNearItem(nearItem, groupKey, addingItemID)
if av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type {
// 因为单选或多选只能按选项分组,并且可能存在空白分组(找不到临近项),所以单选或多选类型的分组字段使用分组值内容对应的选项
if opt := groupKey.GetOption(groupView.GetGroupValue()); nil != opt && groupValueDefault != groupView.GetGroupValue() {
if nil == newValue {
newValue = ret[groupKey.ID] // 如果没有临近项,则尝试从过滤结果中获取
}
if nil == newValue {
newValue = keyValues.GetValue(addingItemID) // 尝试从已有值中获取
}
if nil != newValue {
if !av.MSelectExistOption(newValue.MSelect, groupView.GetGroupValue()) {
if 1 > len(newValue.MSelect) || av.KeyTypeMSelect == groupKey.Type {
newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
} else {
newValue.MSelect = []*av.ValueSelect{newAttrViewValueSelect(opt)}
}
} else {
var vals []*av.ValueSelect
if isCreate {
vals = append(vals, newAttrViewValueSelect(opt))
} else {
existingVal := keyValues.GetValue(addingItemID)
if nil != existingVal {
if !av.MSelectExistOption(existingVal.MSelect, opt.Name) {
existingVal.MSelect = append(existingVal.MSelect, newAttrViewValueSelect(opt))
}
vals = existingVal.MSelect
} else {
vals = append(vals, newAttrViewValueSelect(opt))
}
}
// 添加过滤结果选项的值
if nil != ret[groupKey.ID] {
for _, v := range ret[groupKey.ID].MSelect {
if !av.MSelectExistOption(vals, v.Content) {
vals = append(vals, v)
}
}
}
newValue.MSelect = vals
}
} else {
newValue = av.GetAttributeViewDefaultValue(ast.NewNodeID(), groupKey.ID, addingItemID, groupKey.Type, false)
newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
}
}
if nil != newValue {
ret[groupKey.ID] = newValue
}
return
}
if av.KeyTypeTemplate == keyValues.Key.Type && nil != nearItem {
if keys := templateRelevantKeys[keyValues.Key.ID]; 0 < len(keys) {
for _, k := range keys {
if nil == ret[k.ID] {
ret[k.ID] = getNewValueByNearItem(nearItem, k, addingItemID)
}
}
}
return
}
if av.KeyTypeRollup == keyValues.Key.Type && nil != nearItem {
if relKey, ok := rollupRelevantKeys[keyValues.Key.ID]; ok {
if nil == ret[relKey.ID] {
ret[relKey.ID] = getNewValueByNearItem(nearItem, relKey, addingItemID)
}
}
return
}
if nil != nearItem && filterKeyIDs[groupKey.ID] {
// 临近项不为空并且分组字段和过滤字段相同时,优先使用临近项 https://github.com/siyuan-note/siyuan/issues/15591
newValue = getNewValueByNearItem(nearItem, groupKey, addingItemID)
ret[groupKey.ID] = newValue
return
}
if nil == nearItem && !filterKeyIDs[groupKey.ID] {
// 没有临近项并且分组字段和过滤字段不同时,使用分组值
newValue = av.GetAttributeViewDefaultValue(ast.NewNodeID(), groupKey.ID, addingItemID, groupKey.Type, false)
if av.KeyTypeText == groupView.GroupVal.Type {
content := groupView.GroupVal.Text.Content
if groupValueDefault == content {
content = ""
}
switch newValue.Type {
case av.KeyTypeBlock:
newValue.Block.Content = content
case av.KeyTypeText:
newValue.Text.Content = content
case av.KeyTypeNumber:
num, _ := strconv.ParseFloat(strings.Split(content, " - ")[0], 64)
newValue.Number.Content = num
newValue.Number.IsNotEmpty = true
case av.KeyTypeURL:
newValue.URL.Content = content
case av.KeyTypeEmail:
newValue.Email.Content = content
case av.KeyTypePhone:
newValue.Phone.Content = content
}
} else if av.KeyTypeCheckbox == groupView.GroupVal.Type {
newValue.Checkbox.Checked = groupView.GroupVal.Checkbox.Checked
} else if av.KeyTypeRelation == groupKey.Type && av.KeyTypeRelation == groupView.GroupVal.Type &&
nil != groupView.GroupVal.Relation && 0 < len(groupView.GroupVal.Relation.BlockIDs) {
newValue.Relation.BlockIDs = []string{groupView.GroupVal.Relation.BlockIDs[0]}
}
ret[groupKey.ID] = newValue
return
}
if nil != newValue && !filterKeyIDs[groupKey.ID] {
ret[groupKey.ID] = newValue
}
return
}
func normalizeAttrViewAddingDefaultValue(key *av.Key, value *av.Value) {
if nil == key || nil == value {
return
}
if av.KeyTypeDate == value.Type && nil != value.Date {
value.Date.IsNotTime = true
if nil != key.Date {
value.Date.IsNotTime = !key.Date.FillSpecificTime
if key.Date.AutoFillNow {
value.Date.Content = util.CurrentTimeMillis()
value.Date.IsNotEmpty = true
}
}
}
if av.KeyTypeRelation == value.Type && nil != value.Relation {
value.Relation.Contents = nil
}
}
func firstAttributeViewFilterContext(contexts []*av.FilterContext) *av.FilterContext {
if 0 < len(contexts) {
return contexts[0]
}
return nil
}
// applyFilterDefaultValues 递归遍历过滤节点树,对叶子节点计算新增行的默认值。
// AND 分组合并后验证所有子节点,OR 分组采用首个可满足的分支;无法满足时不生成默认值。
// 返回 true 表示遇到 mAsset 过滤,调用方应立即终止全部默认值计算并丢弃已累积结果。
func applyFilterDefaultValues(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string, nearItem av.Item,
templateRelevantKeys map[string][]*av.Key, rollupRelevantKeys map[string]*av.Key,
ret map[string]*av.Value, filterKeyIDs map[string]bool) (stop bool) {
originalRet := cloneDefaultValues(ret)
originalFilterKeyIDs := cloneBoolMap(filterKeyIDs)
if applyFilterDefaultValues0(filters, attrView, addingItemID, nearItem, templateRelevantKeys, rollupRelevantKeys,
ret, filterKeyIDs) {
return true
}
if !filterBranchesMatchDefaultValues(filters, attrView, addingItemID, ret) {
replaceDefaultValues(ret, originalRet)
replaceBoolMap(filterKeyIDs, originalFilterKeyIDs)
}
return false
}
func applyFilterDefaultValues0(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string, nearItem av.Item,
templateRelevantKeys map[string][]*av.Key, rollupRelevantKeys map[string]*av.Key,
ret map[string]*av.Value, filterKeyIDs map[string]bool) (stop bool) {
for _, filter := range filters {
if nil == filter {
continue
}
if filter.IsGroup() {
if av.FilterCombinationOr == filter.Combination && 0 < len(filter.Filters) {
for _, child := range filter.Filters {
candidateRet := cloneDefaultValues(ret)
candidateFilterKeyIDs := cloneBoolMap(filterKeyIDs)
childStop := applyFilterDefaultValues([]*av.ViewFilter{child}, attrView, addingItemID, nearItem,
templateRelevantKeys, rollupRelevantKeys, candidateRet, candidateFilterKeyIDs)
if childStop || filterBranchMatchesDefaultValues(child, attrView, addingItemID, candidateRet) {
replaceDefaultValues(ret, candidateRet)
replaceBoolMap(filterKeyIDs, candidateFilterKeyIDs)
if childStop {
return true
}
break
}
}
continue
}
if applyFilterDefaultValues(filter.Filters, attrView, addingItemID, nearItem, templateRelevantKeys,
rollupRelevantKeys, ret, filterKeyIDs) {
return true
}
continue
}
keyValues, _ := attrView.GetKeyValues(filter.Column)
if nil == keyValues {
continue
}
if !filter.IsValid() {
continue
}
if av.ValueSourceRendered == filter.ValueSource {
// 显示模板结果无法反向推导字段存储值。
continue
}
filterKeyIDs[filter.Column] = true
if av.KeyTypeTemplate == keyValues.Key.Type && nil != nearItem {
if keys := templateRelevantKeys[keyValues.Key.ID]; 0 < len(keys) {
for _, k := range keys {
if nil == ret[k.ID] {
ret[k.ID] = getNewValueByNearItem(nearItem, k, addingItemID)
}
}
}
continue
}
if av.KeyTypeRollup == keyValues.Key.Type && nil != nearItem {
if relKey, ok := rollupRelevantKeys[keyValues.Key.ID]; ok {
if nil == ret[relKey.ID] {
ret[relKey.ID] = getNewValueByNearItem(nearItem, relKey, addingItemID)
}
}
continue
}
if av.KeyTypeMAsset == keyValues.Key.Type {
if nil != nearItem {
if _, ok := ret[keyValues.Key.ID]; !ok {
ret[keyValues.Key.ID] = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID)
}
}
return true // 保留原语义:遇到 mAsset 过滤即结束默认值计算
}
newValue, allowNearItem := filter.GetAffectValue(keyValues.Key, addingItemID)
if nil == newValue && allowNearItem {
newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID)
}
if nil != newValue {
ret[keyValues.Key.ID] = newValue
}
}
return false
}
func cloneDefaultValues(values map[string]*av.Value) (ret map[string]*av.Value) {
ret = make(map[string]*av.Value, len(values))
maps.Copy(ret, values)
return
}
func cloneBoolMap(values map[string]bool) (ret map[string]bool) {
ret = make(map[string]bool, len(values))
maps.Copy(ret, values)
return
}
func filterBranchesMatchDefaultValues(filters []*av.ViewFilter, attrView *av.AttributeView, addingItemID string,
values map[string]*av.Value) bool {
for _, filter := range filters {
if !filterBranchMatchesDefaultValues(filter, attrView, addingItemID, values) {
return false
}
}
return true
}
func filterBranchMatchesDefaultValues(filter *av.ViewFilter, attrView *av.AttributeView, addingItemID string,
values map[string]*av.Value) bool {
if nil == filter {
return false
}
if filter.IsGroup() {
if 1 > len(filter.Filters) {
return av.FilterCombinationOr != filter.Combination
}
if av.FilterCombinationOr == filter.Combination {
for _, child := range filter.Filters {
if filterBranchMatchesDefaultValues(child, attrView, addingItemID, values) {
return true
}
}
return false
}
return filterBranchesMatchDefaultValues(filter.Filters, attrView, addingItemID, values)
}
keyValues, _ := attrView.GetKeyValues(filter.Column)
if nil == keyValues {
return false
}
if !filter.IsValid() {
return true
}
if av.ValueSourceRendered == filter.ValueSource {
// 显示模板结果无法在新增条目时根据存储值准确判断。
return true
}
if av.HasKeyGroup(keyValues.Key.Type, av.KeyGroupRenderDependentFilter) {
// 这些字段的最终值需要在渲染阶段计算,此处无法根据存储值准确判断。
return true
}
value := values[filter.Column]
if nil == value {
value = av.GetAttributeViewDefaultValue(ast.NewNodeID(), filter.Column, addingItemID, keyValues.Key.Type, false)
}
return value.Filter(filter, attrView, addingItemID, nil, nil)
}
func applyAttributeViewContextFilterDefaultValue(attrView *av.AttributeView, addingItemID string,
context *av.FilterContext, values map[string]*av.Value) {
if nil == attrView || nil == context || "" == context.KeyID || 1 > len(context.CurrentDocumentItemIDs) {
return
}
keyValues, err := attrView.GetKeyValues(context.KeyID)
if nil != err || nil == keyValues || nil == keyValues.Key || av.KeyTypeRelation != keyValues.Key.Type {
return
}
value := values[context.KeyID]
if nil == value {
if existing := keyValues.GetValue(addingItemID); nil != existing {
value = existing.Clone()
}
}
if nil == value {
value = av.GetAttributeViewDefaultValue(ast.NewNodeID(), context.KeyID, addingItemID,
av.KeyTypeRelation, false)
}
if nil == value.Relation {
value.Relation = &av.ValueRelation{}
}
seen := map[string]bool{}
blockIDs := value.Relation.BlockIDs[:0]
for _, itemID := range value.Relation.BlockIDs {
if "" == itemID || seen[itemID] {
continue
}
seen[itemID] = true
blockIDs = append(blockIDs, itemID)
}
value.Relation.BlockIDs = blockIDs
for _, itemID := range context.CurrentDocumentItemIDs {
if "" == itemID || seen[itemID] {
continue
}
seen[itemID] = true
value.Relation.BlockIDs = append(value.Relation.BlockIDs, itemID)
}
values[context.KeyID] = value
}
func replaceDefaultValues(target, source map[string]*av.Value) {
clear(target)
maps.Copy(target, source)
}
func replaceBoolMap(target, source map[string]bool) {
clear(target)
maps.Copy(target, source)
}
func (tx *Transaction) doSortAttrViewGroup(operation *Operation) (ret *TxErr) {
if err := sortAttributeViewGroup(operation.AvID, operation.BlockID, operation.PreviousID, operation.ID); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func sortAttributeViewGroup(avID, blockID, previousGroupID, groupID string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return err
}
sortGroupViews(attrView, view)
var groupView *av.View
var index, previousIndex int
for i, g := range view.Groups {
if g.ID == groupID {
groupView = g
index = i
break
}
}
if nil == groupView {
return
}
view.Group.Order = av.GroupOrderMan
view.Groups = append(view.Groups[:index], view.Groups[index+1:]...)
for i, g := range view.Groups {
if g.ID == previousGroupID {
previousIndex = i + 1
break
}
}
view.Groups = slices.Insert(view.Groups, previousIndex, groupView)
for i, g := range view.Groups {
g.GroupSort = i
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doRemoveAttrViewGroup(operation *Operation) (ret *TxErr) {
if err := removeAttributeViewGroup(operation.AvID, operation.BlockID); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func removeAttributeViewGroup(avID, blockID string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return err
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return err
}
removeAttributeViewGroup0(view)
err = av.SaveAttributeView(attrView)
if err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return err
}
return nil
}
func removeAttributeViewGroup0(view *av.View) {
view.Group, view.Groups, view.GroupCreated = nil, nil, 0
}
func (tx *Transaction) doSyncAttrViewTableColWidth(operation *Operation) (ret *TxErr) {
err := syncAttrViewTableColWidth(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func syncAttrViewTableColWidth(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view := attrView.GetView(operation.ID)
if nil == view {
err = av.ErrViewNotFound
logging.LogErrorf("view [%s] not found in attribute view [%s]", operation.ID, operation.AvID)
return
}
var width string
switch view.LayoutType {
case av.LayoutTypeList, av.LayoutTypeCalendar:
return
case av.LayoutTypeTable:
for _, column := range view.Table.Columns {
if column.ID == operation.KeyID {
width = column.Width
break
}
}
case av.LayoutTypeGallery, av.LayoutTypeKanban:
return
}
for _, v := range attrView.Views {
if av.LayoutTypeTable == v.LayoutType {
for _, column := range v.Table.Columns {
if column.ID == operation.KeyID {
column.Width = width
break
}
}
}
}
err = av.SaveAttributeView(attrView)
ReloadAttrView(attrView.ID)
return
}
func (tx *Transaction) doHideAttrViewGroup(operation *Operation) (ret *TxErr) {
if err := hideAttributeViewGroup(operation.AvID, operation.BlockID, operation.ID, int(operation.Data.(float64))); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func hideAttributeViewGroup(avID, blockID, groupID string, hidden int) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
for _, group := range view.Groups {
if group.ID == groupID {
group.GroupHidden = hidden
break
}
}
err = av.SaveAttributeView(attrView)
if err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
return
}
func (tx *Transaction) doHideAttrViewAllGroups(operation *Operation) (ret *TxErr) {
if err := hideAttributeViewAllGroups(operation.AvID, operation.BlockID, operation.Data.(bool)); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func hideAttributeViewAllGroups(avID, blockID string, hidden bool) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
for _, group := range view.Groups {
if hidden {
group.GroupHidden = 2
} else {
group.GroupHidden = 0
}
}
err = av.SaveAttributeView(attrView)
if err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
return
}
func (tx *Transaction) doFoldAttrViewGroup(operation *Operation) (ret *TxErr) {
if err := foldAttrViewGroup(operation.AvID, operation.BlockID, operation.ID, operation.Data.(bool)); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func foldAttrViewGroup(avID, blockID, groupID string, folded bool) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return err
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return err
}
if !view.IsGroupView() {
return
}
for _, group := range view.Groups {
if group.ID == groupID {
group.GroupFolded = folded
break
}
}
err = av.SaveAttributeView(attrView)
if err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return err
}
return nil
}
func (tx *Transaction) doFoldAttrViewGroups(operation *Operation) (ret *TxErr) {
folded := map[string]bool{}
data, err := gulu.JSON.MarshalJSON(operation.Data)
if nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = gulu.JSON.UnmarshalJSON(data, &folded); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = foldAttrViewGroups(operation.AvID, operation.BlockID, operation.ViewID, folded); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func foldAttrViewGroups(avID, blockID, viewID string, folded map[string]bool) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return err
}
var view *av.View
if "" != viewID {
view = attrView.GetView(viewID)
if nil == view {
return av.ErrViewNotFound
}
} else {
view, err = getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return err
}
}
if !view.IsGroupView() {
return
}
for _, group := range view.Groups {
if groupFolded, ok := folded[group.ID]; ok {
group.GroupFolded = groupFolded
}
}
err = av.SaveAttributeView(attrView)
if err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return err
}
return nil
}
func (tx *Transaction) doSetAttrViewGroup(operation *Operation) (ret *TxErr) {
data, err := gulu.JSON.MarshalJSON(operation.Data)
if nil != err {
logging.LogErrorf("marshal operation data failed: %s", err)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
group := &av.ViewGroup{}
if err = gulu.JSON.UnmarshalJSON(data, &group); nil != err {
logging.LogErrorf("unmarshal operation data failed: %s", err)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = SetAttributeViewGroup(operation.AvID, operation.BlockID, group); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func SetAttributeViewGroup(avID, blockID string, group *av.ViewGroup) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return err
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return err
}
setAttributeViewGroup(attrView, view, group)
err = av.SaveAttributeView(attrView)
ReloadAttrView(avID)
return
}
func setAttributeViewGroup(attrView *av.AttributeView, view *av.View, group *av.ViewGroup) {
if nil == group || "" == group.Field {
removeAttributeViewGroup0(view)
return
}
if av.ValueSourceRendered == group.ValueSource {
group.Method = av.GroupMethodValue
group.Range = nil
if av.GroupOrderSelectOption == group.Order {
group.Order = av.GroupOrderAsc
}
}
var firstInit, changeGroupField bool
if nil != view.Group {
changeGroupField = group.Field != view.Group.Field
} else {
firstInit = true
}
groupStates := getAttrViewGroupStates(view)
view.Group = group
genAttrViewGroups(view, attrView)
setAttrViewGroupStates(view, groupStates)
syncAttrViewGroupHiddenStates(attrView, view)
if (firstInit || changeGroupField) && av.ValueSourceRendered != group.ValueSource { // 首次设置分组时
if groupKey := view.GetGroupKey(attrView); nil != groupKey {
if av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type {
// 如果分组字段是单选或多选,则将分组排序方式改为按选项排序 https://github.com/siyuan-note/siyuan/issues/15534
view.Group.Order = av.GroupOrderSelectOption
sortGroupsBySelectOption(view, groupKey)
} else if av.KeyTypeCheckbox == groupKey.Type {
// 如果分组字段是复选框,则将分组排序改为手动排序,并且已勾选在前面
view.Group.Order = av.GroupOrderMan
checked := view.GetGroupByGroupValue(av.CheckboxCheckedStr)
unchecked := view.GetGroupByGroupValue("")
view.Groups = nil
view.Groups = append(view.Groups, checked, unchecked)
}
}
for i, g := range view.Groups {
g.GroupSort = i
}
}
}
func syncAttrViewGroupHiddenStates(attrView *av.AttributeView, view *av.View) {
if !view.IsGroupView() {
return
}
if !view.Group.HideEmpty {
for _, groupView := range view.Groups {
if 2 != groupView.GroupHidden {
groupView.GroupHidden = 0
}
}
return
}
viewable := sql.RenderView(attrView, view, "", false)
cachedAttrViews := map[string]*av.AttributeView{}
rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
if table := av.TableFromViewable(viewable); nil != table {
// 过滤只依赖行字段值,先对完整父表执行一次,再按分组成员关系判断空分组。
filtered := *table
filtered.Rows = append([]*av.TableRow(nil), table.Rows...)
av.Filter(&filtered, attrView, rollupFurtherCollections, cachedAttrViews)
visibleItemIDs := make(map[string]bool, len(filtered.Rows))
for _, row := range filtered.Rows {
visibleItemIDs[row.ID] = true
}
for _, groupView := range view.Groups {
if 2 == groupView.GroupHidden {
continue
}
groupView.GroupHidden = 1
for _, itemID := range groupView.GroupItemIDs {
if visibleItemIDs[itemID] {
groupView.GroupHidden = 0
break
}
}
}
return
}
for _, groupView := range view.Groups {
if 2 == groupView.GroupHidden {
continue
}
groupViewable := sql.RenderGroupView(attrView, view, groupView, "")
av.Filter(groupViewable, attrView, rollupFurtherCollections, cachedAttrViews)
if 1 > groupViewable.(av.Collection).CountItems() {
groupView.GroupHidden = 1
} else {
groupView.GroupHidden = 0
}
}
}
func (tx *Transaction) doSetAttrViewCardAspectRatio(operation *Operation) (ret *TxErr) {
err := setAttrViewCardAspectRatio(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardAspectRatio(operation *Operation) (err error) {
value, err := getAttrViewOperationNumber(operation)
if nil != err {
return
}
ratio := av.CardAspectRatio(value)
if value != math.Trunc(value) || ratio < av.CardAspectRatio16_9 || av.CardAspectRatio1_1 < ratio {
return fmt.Errorf("invalid card aspect ratio preset [%v]", value)
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CardAspectRatio = ratio
cards.CardAspectRatioValue = av.CardAspectRatioValueByPreset(ratio)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCardAspectRatioValue(operation *Operation) (ret *TxErr) {
if err := setAttrViewCardAspectRatioValue(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardAspectRatioValue(operation *Operation) (err error) {
ratio, err := getAttrViewOperationNumber(operation)
if nil != err {
return
}
if math.IsNaN(ratio) || math.IsInf(ratio, 0) ||
ratio < av.CardAspectRatioValueMin || av.CardAspectRatioValueMax < ratio {
return fmt.Errorf("invalid card aspect ratio [%v]", ratio)
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CardAspectRatioValue = ratio
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewBlockView(operation *Operation) (ret *TxErr) {
err := SetDatabaseBlockView(operation.BlockID, operation.AvID, operation.ID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewBlockVisibleViews(operation *Operation) (ret *TxErr) {
err := SetDatabaseBlockVisibleViews(operation.BlockID, operation.AvID, operation.ViewIDs)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func SetDatabaseBlockVisibleViews(blockID, avID string, viewIDs []string) (err error) {
if 1 > len(viewIDs) {
return errors.New("at least one visible view is required")
}
attrView, err := avParseView(avID, blockID)
if nil != err {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
visible := map[string]bool{}
for _, viewID := range viewIDs {
if nil == attrView.GetView(viewID) {
return fmt.Errorf("view [%s] not found in attribute view [%s]", viewID, avID)
}
visible[viewID] = true
}
var normalized []string
for _, view := range attrView.Views {
if visible[view.ID] {
normalized = append(normalized, view.ID)
}
}
if 1 > len(normalized) {
return errors.New("at least one visible view is required")
}
node, tree, err := getAttributeViewInstanceNode(attrView, blockID)
if nil != err {
return
}
err = setNodeAttrs(node, tree, map[string]string{
av.NodeAttrVisibleViewIDs: strings.Join(normalized, ","),
})
return
}
func (tx *Transaction) doChangeAttrViewLayout(operation *Operation) (ret *TxErr) {
err := ChangeAttrViewLayout(operation.BlockID, operation.AvID, operation.Layout)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func ChangeAttrViewLayout(blockID, avID string, newLayout av.LayoutType) (err error) {
return ChangeAttrViewLayoutForView(blockID, avID, "", "", newLayout)
}
// ChangeAttrViewLayoutForView 精确修改指定视图的布局,并同步显示该视图的镜像数据库块。
func ChangeAttrViewLayoutForView(blockID, avID, viewID, revision string, newLayout av.LayoutType) (err error) {
if "" != viewID {
FlushTxQueue()
}
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
var view *av.View
if "" != viewID {
if _, _, err = getAttributeViewInstanceNode(attrView, blockID); nil != err {
return
}
view = attrView.GetView(viewID)
if nil == view {
return av.ErrViewNotFound
}
if err = checkAttributeViewViewConfigRevision(view, revision); nil != err {
return
}
} else {
view, err = getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
}
if newLayout == view.LayoutType {
return
}
if err = changeAttrViewLayout(attrView, view, newLayout); err != nil {
return
}
blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
for _, bID := range blockIDs {
node, tree, _ := getNodeByBlockID(nil, bID)
if nil == node || nil == tree {
logging.LogErrorf("get node by block ID [%s] failed", bID)
continue
}
changed := false
attrs := parse.IAL2Map(node.KramdownIAL)
if blockID == bID && "" == viewID { // 当前操作的镜像库
attrs[av.NodeAttrView] = view.ID
node.AttributeViewType = string(view.LayoutType)
changed = true
} else {
if view.ID == attrs[av.NodeAttrView] {
// 仅更新和当前操作的镜像库指定的视图相同的镜像库
node.AttributeViewType = string(view.LayoutType)
changed = true
}
}
if changed {
err = setNodeAttrs(node, tree, attrs)
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", bID, err)
return
}
}
}
regenAttrViewGroups(attrView)
if err = avSaveView(attrView, blockID); nil != err {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
ReloadAttrView(avID)
return
}
func changeAttrViewLayout(attrView *av.AttributeView, view *av.View, newLayout av.LayoutType) (err error) {
if newLayout == view.LayoutType {
return
}
switch newLayout {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar, av.LayoutTypeGallery, av.LayoutTypeKanban:
default:
return av.ErrWrongLayoutType
}
oldLayout := view.LayoutType
oldFields := attributeViewFieldIDs(view)
view.LayoutType = newLayout
if oldLayout == av.LayoutTypeCalendar && view.Name == av.GetAttributeViewI18n(string(oldLayout)) {
view.Name = av.GetAttributeViewI18n(string(newLayout))
}
switch newLayout {
case av.LayoutTypeCalendar:
if view.Name == av.GetAttributeViewI18n(string(oldLayout)) {
view.Name = av.GetAttributeViewI18n("calendar")
}
if nil == view.Calendar {
view.Calendar = newAttributeViewCalendarLayout(attrView, oldFields)
}
case av.LayoutTypeList:
if view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("gallery") || view.Name == av.GetAttributeViewI18n("kanban") {
view.Name = av.GetAttributeViewI18n("list")
}
if nil == view.List {
view.List = newAttributeViewListLayout(attrView, oldFields)
}
case av.LayoutTypeTable:
if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("gallery") || view.Name == av.GetAttributeViewI18n("kanban") {
view.Name = av.GetAttributeViewI18n("table")
}
if nil != view.Table {
break
}
view.Table = av.NewLayoutTable()
for _, id := range oldFields {
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: id}})
}
case av.LayoutTypeGallery:
if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("kanban") {
view.Name = av.GetAttributeViewI18n("gallery")
}
if nil != view.Gallery {
break
}
view.Gallery = av.NewLayoutGallery()
for _, id := range oldFields {
view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: id}})
}
case av.LayoutTypeKanban:
if oldLayout == av.LayoutTypeList && view.Name == av.GetAttributeViewI18n("list") || view.Name == av.GetAttributeViewI18n("table") || view.Name == av.GetAttributeViewI18n("gallery") {
view.Name = av.GetAttributeViewI18n("kanban")
}
if nil != view.Kanban {
break
}
view.Kanban = av.NewLayoutKanban()
for _, id := range oldFields {
view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: id}})
}
if !view.IsGroupView() {
preferredGroupKey := getKanbanPreferredGroupKey(attrView)
group := &av.ViewGroup{Field: preferredGroupKey.ID}
setAttributeViewGroup(attrView, view, group)
}
}
return
}
func (tx *Transaction) doSetAttrViewWrapField(operation *Operation) (ret *TxErr) {
err := setAttrViewWrapField(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewWrapField(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
allFieldWrap := operation.Data.(bool)
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
view.GetTableLayout().WrapField = allFieldWrap
for _, col := range view.GetTableLayout().Columns {
col.Wrap = allFieldWrap
}
case av.LayoutTypeGallery:
view.Gallery.WrapField = allFieldWrap
for _, field := range view.Gallery.CardFields {
field.Wrap = allFieldWrap
}
case av.LayoutTypeKanban:
view.Kanban.WrapField = allFieldWrap
for _, field := range view.Kanban.Fields {
field.Wrap = allFieldWrap
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewShowIcon(operation *Operation) (ret *TxErr) {
err := setAttrViewShowIcon(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewShowIcon(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
base := view.GetBaseLayout()
if nil == base {
return
}
base.ShowIcon = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewFitImage(operation *Operation) (ret *TxErr) {
err := setAttrViewFitImage(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewFitImage(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.FitImage = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewDisplayFieldName(operation *Operation) (ret *TxErr) {
err := setAttrViewDisplayFieldName(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewDisplayEmptyFields(operation *Operation) (ret *TxErr) {
err := setAttrViewDisplayEmptyFields(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewFillColBackgroundColor(operation *Operation) (ret *TxErr) {
err := setAttrViewFillColBackgroundColor(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewDisplayFieldName(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewOperationView(attrView, operation)
if err != nil {
return
}
if cards := view.GetCardSettings(); nil != cards {
cards.DisplayFieldName = operation.Data.(bool)
} else if av.LayoutTypeCalendar == view.LayoutType {
view.Calendar.Settings.DisplayFieldName = operation.Data.(bool)
} else {
return
}
err = av.SaveAttributeView(attrView)
return
}
func setAttrViewDisplayEmptyFields(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.DisplayEmptyFields = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func setAttrViewFillColBackgroundColor(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
if av.LayoutTypeKanban != view.LayoutType || nil == view.Kanban {
return
}
view.Kanban.FillColBackgroundColor = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCardSize(operation *Operation) (ret *TxErr) {
err := setAttrViewCardSize(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardSize(operation *Operation) (err error) {
value, err := getAttrViewOperationNumber(operation)
if nil != err {
return
}
size := av.CardSize(value)
if value != math.Trunc(value) || size < av.CardSizeSmall || av.CardSizeLarge < size {
return fmt.Errorf("invalid card size preset [%v]", value)
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CardSize = size
cards.CardWidth = av.CardWidthBySize(size)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCardWidth(operation *Operation) (ret *TxErr) {
if err := setAttrViewCardWidth(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardWidth(operation *Operation) (err error) {
value, err := getAttrViewOperationNumber(operation)
if nil != err {
return
}
if math.IsNaN(value) || math.IsInf(value, 0) || value != math.Trunc(value) ||
value < av.CardWidthMin || av.CardWidthMax < value {
return fmt.Errorf("invalid card width [%v]", value)
}
width := int(value)
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CardWidth = width
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCardLayout(operation *Operation) (ret *TxErr) {
if err := setAttrViewCardLayout(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardLayout(operation *Operation) (err error) {
value, err := getAttrViewOperationNumber(operation)
if nil != err {
return
}
layout := av.CardLayout(value)
if value != math.Trunc(value) || !layout.IsValid() {
return fmt.Errorf("invalid card layout [%v]", value)
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewOperationView(attrView, operation)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return av.ErrWrongLayoutType
}
cards.CardLayout = layout
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColFullRow(operation *Operation) (ret *TxErr) {
if err := setAttrViewColFullRow(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewColFullRow(operation *Operation) (err error) {
fullRow, ok := operation.Data.(bool)
if !ok {
return fmt.Errorf("invalid card field full row value [%v]", operation.Data)
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewOperationView(attrView, operation)
if err != nil {
return
}
found := false
switch view.LayoutType {
case av.LayoutTypeGallery:
for _, field := range view.Gallery.CardFields {
if field.ID == operation.ID {
field.FullRow = fullRow
found = true
break
}
}
case av.LayoutTypeKanban:
for _, field := range view.Kanban.Fields {
if field.ID == operation.ID {
field.FullRow = fullRow
found = true
break
}
}
default:
return av.ErrWrongLayoutType
}
if !found {
return fmt.Errorf("field [%s] not found in view [%s]", operation.ID, view.ID)
}
err = av.SaveAttributeView(attrView)
return
}
func getAttrViewOperationView(attrView *av.AttributeView, operation *Operation) (ret *av.View, err error) {
if "" != operation.ViewID {
ret = attrView.GetView(operation.ViewID)
if nil == ret {
err = av.ErrViewNotFound
}
return
}
return getAttrViewViewByBlockID(attrView, operation.BlockID)
}
func getAttrViewOperationNumber(operation *Operation) (ret float64, err error) {
var ok bool
if ret, ok = operation.Data.(float64); !ok {
err = fmt.Errorf("invalid card configuration value [%v]", operation.Data)
}
return
}
func (tx *Transaction) doSetAttrViewCoverFromAssetKeyID(operation *Operation) (ret *TxErr) {
err := setAttrViewCoverFromAssetKeyID(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCoverFromAssetKeyID(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CoverFromAssetKeyID = operation.KeyID
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCoverFrom(operation *Operation) (ret *TxErr) {
err := setAttrViewCoverFrom(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCoverFrom(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
cards := view.GetCardSettings()
if nil == cards {
return
}
cards.CoverFrom = av.CoverFrom(operation.Data.(float64))
err = av.SaveAttributeView(attrView)
return
}
type setAttrViewCardCoverPositionData struct {
Source string `json:"source"`
Position *av.CardCoverPosition `json:"position"`
}
func (tx *Transaction) doSetAttrViewCardCoverPosition(operation *Operation) (ret *TxErr) {
if err := setAttrViewCardCoverPosition(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCardCoverPosition(operation *Operation) (err error) {
dataJSON, err := json.Marshal(operation.Data)
if nil != err {
return
}
var data setAttrViewCardCoverPositionData
if err = json.Unmarshal(dataJSON, &data); nil != err {
return
}
if !av.IsValidCardCoverSource(data.Source) {
return fmt.Errorf("invalid card cover source [%s]", data.Source)
}
if nil != data.Position {
if "" == data.Position.Image || 32*1024 < len(data.Position.Image) {
return errors.New("invalid card cover image")
}
if math.IsNaN(data.Position.X) || math.IsInf(data.Position.X, 0) ||
math.IsNaN(data.Position.Y) || math.IsInf(data.Position.Y, 0) ||
data.Position.X < 0 || 100 < data.Position.X || data.Position.Y < 0 || 100 < data.Position.Y {
return fmt.Errorf("invalid card cover position [%v, %v]", data.Position.X, data.Position.Y)
}
}
attrView, err := av.ParseAttributeView(operation.AvID)
if nil != err {
return
}
if nil == attrView.GetBlockValue(operation.RowID) {
return fmt.Errorf("attribute view item [%s] not found", operation.RowID)
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if nil != err {
return
}
if av.LayoutTypeGallery != view.LayoutType && av.LayoutTypeKanban != view.LayoutType {
return av.ErrWrongLayoutType
}
var source string
if av.LayoutTypeGallery == view.LayoutType {
source = av.CardCoverSource(view.Gallery.CoverFrom, view.Gallery.CoverFromAssetKeyID)
} else {
source = av.CardCoverSource(view.Kanban.CoverFrom, view.Kanban.CoverFromAssetKeyID)
}
if data.Source != source {
return fmt.Errorf("card cover source [%s] does not match view [%s]", data.Source, view.ID)
}
if keyID := av.CardCoverSourceAssetKeyID(data.Source); "" != keyID {
key, getErr := attrView.GetKey(keyID)
if nil != getErr || nil == key || av.KeyTypeMAsset != key.Type {
return fmt.Errorf("card cover asset field [%s] not found", keyID)
}
}
attrView.SetCardCoverPosition(operation.RowID, data.Source, data.Position)
err = av.SaveAttributeView(attrView)
return
}
func AppendAttributeViewDetachedBlocksWithValues(avID string, blocksValues [][]*av.Value) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
now := util.CurrentTimeMillis()
var blockIDs []string
for _, blockValues := range blocksValues {
blockID := ast.NewNodeID()
if v := blockValues[0]; "" != v.BlockID {
blockID = v.BlockID
}
blockIDs = append(blockIDs, blockID)
for _, v := range blockValues {
keyValues, _ := attrView.GetKeyValues(v.KeyID)
if nil == keyValues {
err = fmt.Errorf("key [%s] not found", v.KeyID)
return
}
v.ID = ast.NewNodeID()
v.BlockID = blockID
v.Type = keyValues.Key.Type
if av.KeyTypeBlock == v.Type {
v.Block.Created = now
v.Block.Updated = now
v.Block.ID = ""
v.Block.RefSubtype = ""
}
v.IsDetached = true
v.CreatedAt = now
v.UpdatedAt = now
v.IsRenderAutoFill = false
keyValues.Values = append(keyValues.Values, v)
if av.KeyTypeSelect == v.Type || av.KeyTypeMSelect == v.Type {
// 保存选项 https://github.com/siyuan-note/siyuan/issues/12475
key, _ := attrView.GetKey(v.KeyID)
if nil != key && 0 < len(v.MSelect) {
for _, valOpt := range v.MSelect {
if opt := key.GetOption(valOpt.Content); nil == opt {
// 不存在的选项新建保存
opt = &av.SelectOption{Name: valOpt.Content, Color: attrView.FilterColorValue(valOpt.Color)}
key.Options = append(key.Options, opt)
} else {
// 已经存在的选项颜色需要保持不变
valOpt.Color = opt.Color
}
}
}
}
}
}
for _, v := range attrView.Views {
for _, addingBlockID := range blockIDs {
v.ItemIDs = append(v.ItemIDs, addingBlockID)
}
}
regenAttrViewGroups(attrView)
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
ReloadAttrView(avID)
return
}
// DuplicateAttributeViewRow 创建源行的纯文本副本,复制除主键、Rollup、Created、Updated 外的所有字段值,
// 双向关联同步更新目标属性视图的反向关联列。新行 ID 由调用方(前端)生成并通过 newRowID 传入,
// 副本插入到 previousItemID(通常为最后选中的条目)之后。
func DuplicateAttributeViewRow(tx *Transaction, avID, previousItemID, srcRowID, newRowID string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
blockKeyValues := attrView.GetBlockKeyValues()
if nil == blockKeyValues {
err = fmt.Errorf("attribute view [%s] has no block key", avID)
return
}
srcBlockVal := blockKeyValues.GetValue(srcRowID)
if nil == srcBlockVal {
err = fmt.Errorf("source row [%s] not found in attribute view [%s]", srcRowID, avID)
return
}
if "" == newRowID {
newRowID = ast.NewNodeID()
}
now := util.CurrentTimeMillis()
// 创建副本的主键值,强制为纯文本(非绑定块)
blockContent := ""
if nil != srcBlockVal.Block {
blockContent = srcBlockVal.Block.Content
}
newBlockVal := &av.Value{
ID: ast.NewNodeID(),
KeyID: blockKeyValues.Key.ID,
BlockID: newRowID,
Type: av.KeyTypeBlock,
IsDetached: true,
CreatedAt: now,
UpdatedAt: now,
Block: &av.ValueBlock{Content: blockContent, Created: now, Updated: now},
}
blockKeyValues.Values = append(blockKeyValues.Values, newBlockVal)
// 收集双向关联字段,循环结束后统一处理,避免跨属性视图重复 parse/save
type pendingTwoWay struct {
key *av.Key
val *av.Value
}
var pendingTwoWays []*pendingTwoWay
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeBlock == keyValues.Key.Type {
continue // 主键已处理
}
if av.HasKeyGroup(keyValues.Key.Type, av.KeyGroupSkipRowCopy) {
continue // 汇总/创建时间/更新时间字段在渲染或自动生成时处理,不复制
}
srcVal := keyValues.GetValue(srcRowID)
if nil == srcVal {
continue // 源行该字段无值,跳过
}
newVal := srcVal.Clone()
if nil == newVal {
continue
}
newVal.ID = ast.NewNodeID()
newVal.BlockID = newRowID
newVal.IsDetached = false
newVal.CreatedAt = now
newVal.UpdatedAt = now
newVal.IsRenderAutoFill = false
if nil != newVal.Relation {
newVal.Relation.Contents = nil // 清除渲染期数据
}
// 单选/多选选项同步,保证目标属性视图存在对应选项 https://github.com/siyuan-note/siyuan/issues/12475
if av.KeyTypeSelect == newVal.Type || av.KeyTypeMSelect == newVal.Type {
if 0 < len(newVal.MSelect) {
for _, valOpt := range newVal.MSelect {
if opt := keyValues.Key.GetOption(valOpt.Content); nil == opt {
opt = &av.SelectOption{Name: valOpt.Content, Color: attrView.FilterColorValue(valOpt.Color)}
keyValues.Key.Options = append(keyValues.Key.Options, opt)
} else {
valOpt.Color = opt.Color
}
}
}
}
keyValues.Values = append(keyValues.Values, newVal)
// 双向关联值收集,稍后统一更新目标属性视图的反向列
if av.KeyTypeRelation == newVal.Type && nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay && 0 < len(newVal.Relation.BlockIDs) {
pendingTwoWays = append(pendingTwoWays, &pendingTwoWay{key: keyValues.Key, val: newVal})
}
}
// 在所有视图上添加新行,插入位置为 previousItemID 之后
for _, v := range attrView.Views {
addRowToViewItems(v, newRowID, previousItemID)
}
attrView.CopyCardCoverPositions(srcRowID, newRowID)
// 统一处理双向关联:按目标属性视图聚合,每个目标只 parse/save 一次
twoWayByDestAv := map[string][]*pendingTwoWay{}
for _, p := range pendingTwoWays {
destAvID := p.key.Relation.AvID
twoWayByDestAv[destAvID] = append(twoWayByDestAv[destAvID], p)
}
for destAvID, items := range twoWayByDestAv {
if destAvID == attrView.ID {
// 自关联,直接在内存对象上更新,随主属性视图一起保存
for _, p := range items {
updateTwoWayRelationDestAttrView(attrView, p.key, p.val, 1, nil)
}
continue
}
destAv, parseErr := av.ParseAttributeView(destAvID)
if nil != parseErr || nil == destAv {
logging.LogWarnf("parse dest attribute view [%s] failed: %s", destAvID, parseErr)
continue
}
for _, p := range items {
// 复用反向更新逻辑,传入 mode=1(增加)、oldBlockIDs 为空
updateTwoWayRelationDestAttrView(destAv, p.key, p.val, 1, nil)
}
regenAttrViewGroups(destAv)
if saveErr := av.SaveAttributeView(destAv); nil != saveErr {
logging.LogErrorf("save dest attribute view [%s] failed: %s", destAvID, saveErr)
}
if nil != tx {
tx.relatedAvIDs = append(tx.relatedAvIDs, destAvID)
}
ReloadAttrView(destAvID)
}
regenAttrViewGroups(attrView)
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
return
}
// addRowToViewItems 将 newRowID 插入到视图及其所有分组的项目列表中,位置在 previousItemID 之后;
// 若 previousItemID 为空或未找到,则追加到末尾。
func addRowToViewItems(view *av.View, newRowID, previousItemID string) {
view.ItemIDs = insertItemAfter(view.ItemIDs, newRowID, previousItemID)
for _, g := range view.Groups {
g.GroupItemIDs = insertItemAfter(g.GroupItemIDs, newRowID, previousItemID)
}
}
// insertItemAfter 将 item 插入到 items 中 previousItemID 之后;若 previousItemID 为空或未找到,则追加到末尾。
func insertItemAfter(items []string, item, previousItemID string) []string {
if "" != previousItemID {
for i, id := range items {
if id == previousItemID {
items = append(items[:i+1], append([]string{item}, items[i+1:]...)...)
return items
}
}
}
return append(items, item)
}
func DuplicateDatabaseBlock(avID string) (newAvID, newBlockID string, err error) {
// 加密笔记本的 AV 定义在笔记本级目录,通过 fallback 查找实际路径
oldAvPath, avBoxID := av.FindAttributeViewPath(avID)
if oldAvPath == "" {
oldAvPath = av.GetAttributeViewDataPath(avID)
}
newAvID, newBlockID = ast.NewNodeID(), ast.NewNodeID()
oldAv, err := av.ParseAttributeView(avID)
if err != nil {
return
}
data, err := filelock.ReadFile(oldAvPath)
if err != nil {
logging.LogErrorf("read attribute view [%s] failed: %s", avID, err)
return
}
// 加密笔记本的 AV 是密文,需先解密再处理(av.DecryptAVData 内部按 box 加密/已解锁路由)
if avBoxID != "" && IsEncryptedBox(avBoxID) {
var decErr error
data, decErr = av.DecryptAVData(avBoxID, avID, data)
if decErr != nil {
logging.LogErrorf("decrypt attribute view [%s] failed: %s", avID, decErr)
err = decErr
return
}
}
data = bytes.ReplaceAll(data, []byte(avID), []byte(newAvID))
av.UpsertBlockRel(newAvID, newBlockID)
newAv := &av.AttributeView{}
if err = gulu.JSON.UnmarshalJSON(data, newAv); err != nil {
logging.LogErrorf("unmarshal attribute view [%s] failed: %s", newAvID, err)
return
}
if "" != newAv.Name {
newAv.Name = oldAv.Name + " (Duplicated " + time.Now().Format("2006-01-02 15:04:05") + ")"
}
for _, keyValues := range newAv.KeyValues {
if nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay {
// 断开双向关联
keyValues.Key.Relation.IsTwoWay = false
keyValues.Key.Relation.BackKeyID = ""
}
}
data, err = gulu.JSON.MarshalJSON(newAv)
if err != nil {
logging.LogErrorf("marshal attribute view [%s] failed: %s", newAvID, err)
return
}
// 加密笔记本的新 AV 定义也存笔记本级目录,且需 avKey 加密
newAvPath := filepath.Join(util.DataDir, "storage", "av", newAvID+".json")
if avBoxID != "" {
newAvPath = filepath.Join(util.DataDir, avBoxID, "storage", "av", newAvID+".json")
var encErr error
data, encErr = av.EncryptAVData(avBoxID, newAvID, data)
if encErr != nil {
logging.LogErrorf("encrypt attribute view [%s] failed: %s", newAvID, encErr)
err = encErr
return
}
av.SetAVBoxID(newAvID, avBoxID)
}
if err = filelock.WriteFile(newAvPath, data); err != nil {
logging.LogErrorf("write attribute view [%s] failed: %s", newAvID, err)
return
}
updateBoundBlockAvsAttribute([]string{newAvID}, avBoxID)
return
}
func GetAttributeViewKeysByID(avID string, keyIDs ...string) (ret []*av.Key) {
ret = []*av.Key{}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
if 1 > len(keyIDs) {
for _, keyValues := range attrView.KeyValues {
key := keyValues.Key
ret = append(ret, key)
}
return
}
for _, keyValues := range attrView.KeyValues {
key := keyValues.Key
for _, keyID := range keyIDs {
if key.ID == keyID {
ret = append(ret, key)
}
}
}
return ret
}
func SetDatabaseBlockView(blockID, avID, viewID string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if nil != err {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
view := attrView.GetView(viewID)
if nil == view {
err = av.ErrViewNotFound
logging.LogErrorf("view [%s] not found in attribute view [%s]", viewID, avID)
return
}
node, tree, err := getNodeByBlockID(nil, blockID)
if err != nil {
return
}
node.AttributeViewType = string(view.LayoutType)
attrs := parse.IAL2Map(node.KramdownIAL)
attrs[av.NodeAttrView] = viewID
err = setNodeAttrs(node, tree, attrs)
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", blockID, err)
return
}
return
}
// normalizeDatabaseBlockView 使数据库载体绑定的视图和布局保持一致。
func normalizeDatabaseBlockView(node *ast.Node, attrView *av.AttributeView) (changed bool) {
if nil == node || nil == attrView || ast.NodeAttributeView != node.Type {
return
}
viewID := node.IALAttr(av.NodeAttrView)
var view *av.View
if "" != viewID {
view = attrView.GetView(viewID)
}
if nil == view {
view, _ = attrView.GetFirstView()
}
if nil == view {
return
}
layout := string(view.LayoutType)
if layout != node.AttributeViewType {
node.AttributeViewType = layout
changed = true
}
if view.ID != viewID {
node.SetIALAttr(av.NodeAttrView, view.ID)
changed = true
}
return
}
func normalizeDatabaseBlockViews(node *ast.Node, boxID string, attrViews map[string]*av.AttributeView) (changed bool) {
ast.Walk(node, func(n *ast.Node, entering bool) ast.WalkStatus {
if !entering || ast.NodeAttributeView != n.Type {
return ast.WalkContinue
}
attrView := cachedAttributeViewForBox(n.AttributeViewID, boxID, attrViews)
if normalizeDatabaseBlockView(n, attrView) {
changed = true
}
return ast.WalkContinue
})
return
}
func cachedAttributeViewForBox(avID, boxID string, attrViews map[string]*av.AttributeView) (ret *av.AttributeView) {
cacheKey := boxID + "\x00" + avID
if ret, ok := attrViews[cacheKey]; ok {
return ret
}
var err error
if IsEncryptedBox(boxID) {
ret, err = av.ParseAttributeViewInBox(avID, boxID)
} else {
ret, err = av.ParseAttributeView(avID)
}
if nil != err {
ret = nil
}
attrViews[cacheKey] = ret
return
}
func GetAttributeViewPrimaryKeyValues(avID, keyword string, blockIDs []string, page, pageSize int) (attributeViewName string, databaseBlockIDs []string, keyValues *av.KeyValues, total int, err error) {
waitForSyncingStorages()
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
if normalizeAttributeViewBlockRefSubtypes(attrView) {
if saveErr := av.SaveAttributeView(attrView); nil != saveErr {
logging.LogWarnf("save attribute view [%s] block reference subtypes failed: %s", avID, saveErr)
}
}
attributeViewName = getAttrViewName(attrView)
databaseBlockIDs = treenode.GetMirrorAttrViewBlockIDs(avID)
keyValues = attrView.GetBlockKeyValues()
if nil == keyValues {
keyValues = &av.KeyValues{}
return
}
var values []*av.Value
valuesByBlockID := map[string]*av.Value{}
for _, kv := range keyValues.Values {
if !kv.IsDetached && !treenode.ExistBlockTree(kv.Block.ID) {
continue
}
valuesByBlockID[kv.BlockID] = kv
if strings.Contains(strings.ToLower(kv.String(true)), strings.ToLower(keyword)) {
values = append(values, kv)
}
}
if 0 < len(blockIDs) {
values = nil
for _, blockID := range blockIDs {
if value := valuesByBlockID[blockID]; nil != value {
values = append(values, value)
}
}
keyValues.Values = values
total = len(values)
return
}
keyValues.Values = values
sort.Slice(keyValues.Values, func(i, j int) bool {
if keyValues.Values[i].Block.Updated == keyValues.Values[j].Block.Updated {
return keyValues.Values[i].BlockID > keyValues.Values[j].BlockID
}
return keyValues.Values[i].Block.Updated > keyValues.Values[j].Block.Updated
})
total = len(keyValues.Values)
if 1 > page {
page = 1
}
if 1 > pageSize {
pageSize = 16
}
start := min(len(keyValues.Values), (page-1)*pageSize)
end := min(len(keyValues.Values), start+pageSize)
keyValues.Values = keyValues.Values[start:end]
return
}
func GetAttributeViewRelationCandidates(srcAvID, relationKeyID, keyword string, selectedBlockIDs []string, page, pageSize int, candidateSort *av.ViewSort, blockIDs ...string) (
attributeViewName string, databaseBlockIDs []string, customColors []*av.AttributeViewCustomColor,
columns []*av.TableColumn, selectedRows, rows []*av.TableRow,
total int, err error,
) {
waitForSyncingStorages()
var srcAttrView *av.AttributeView
if len(blockIDs) > 0 && blockIDs[0] != "" {
srcAttrView, err = avParseView(srcAvID, blockIDs[0])
} else {
srcAttrView, err = av.ParseAttributeView(srcAvID)
}
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", srcAvID, err)
return
}
var relationKey *av.Key
attrView := srcAttrView
if "" != relationKeyID {
relationKey, _ = srcAttrView.GetKey(relationKeyID)
if nil == relationKey || av.KeyTypeRelation != relationKey.Type || nil == relationKey.Relation {
err = av.ErrKeyNotFound
return
}
if relationKey.Relation.AvID != srcAvID {
if len(blockIDs) > 0 && blockIDs[0] != "" {
_, boxID := av.FindAttributeViewPath(srcAvID)
attrView, err = av.ParseAttributeViewInBox(relationKey.Relation.AvID, boxID)
} else {
attrView, err = av.ParseAttributeView(relationKey.Relation.AvID)
}
}
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", relationKey.Relation.AvID, err)
return
}
}
attributeViewName = getAttrViewName(attrView)
databaseBlockIDs = treenode.GetMirrorAttrViewBlockIDs(attrView.ID)
customColors = attrView.Palette()
table := renderAttributeViewRelationCandidates(attrView)
if nil == table {
err = av.ErrViewNotFound
return
}
columns = table.Columns
if candidateSort != nil {
if candidateSort.Order != av.SortOrderAsc && candidateSort.Order != av.SortOrderDesc {
err = errors.New("invalid relation candidate sort order")
return
}
found := false
for _, column := range columns {
if column.ID == candidateSort.Column {
found = true
break
}
}
if !found {
err = av.ErrKeyNotFound
return
}
}
rowsByID := map[string]*av.TableRow{}
for _, row := range table.Rows {
rowsByID[row.ID] = row
}
for _, blockID := range selectedBlockIDs {
if row := rowsByID[blockID]; nil != row {
selectedRows = append(selectedRows, row)
}
}
if nil == selectedRows {
selectedRows = []*av.TableRow{}
}
if nil != relationKey && hasAttrViewFilterConditions(relationKey.Relation.CandidateFilters) {
validColumns := map[string]bool{}
for _, keyValues := range attrView.KeyValues {
if nil != keyValues && nil != keyValues.Key {
validColumns[keyValues.Key.ID] = true
}
}
table.Filters, _ = av.PruneInvalidColumnFilters(
av.CloneFilters(relationKey.Relation.CandidateFilters), validColumns)
cachedAttrViews := map[string]*av.AttributeView{attrView.ID: attrView}
av.Filter(table, attrView, sql.GetFurtherCollections(attrView, cachedAttrViews), cachedAttrViews)
}
rows, total = filterSortPageRelationCandidates(table, attrView, keyword, page, pageSize, candidateSort)
return
}
func filterSortPageRelationCandidates(table *av.Table, attrView *av.AttributeView, keyword string, page, pageSize int, candidateSort *av.ViewSort) (
rows []*av.TableRow, total int,
) {
untitled := ""
if strings.TrimSpace(keyword) != "" {
untitled = util.I18nTerm(util.Lang, "untitled")
}
for _, row := range table.Rows {
if relationCandidateMatches(row, keyword, untitled, table.Columns...) {
rows = append(rows, row)
}
}
sort.Slice(rows, func(i, j int) bool {
iCreated := relationCandidateCreatedAt(rows[i])
jCreated := relationCandidateCreatedAt(rows[j])
if iCreated == jCreated {
return rows[i].ID > rows[j].ID
}
return iCreated > jCreated
})
if candidateSort != nil {
table.Rows = rows
table.Sorts = []*av.ViewSort{candidateSort}
av.Sort(table, attrView)
rows = table.Rows
}
total = len(rows)
if 1 > page {
page = 1
}
if 1 > pageSize {
pageSize = 16
}
start := min(len(rows), (page-1)*pageSize)
end := min(len(rows), start+pageSize)
rows = rows[start:end]
if nil == rows {
rows = []*av.TableRow{}
}
return
}
func renderAttributeViewRelationCandidates(attrView *av.AttributeView) (ret *av.Table) {
if nil == attrView {
return
}
keysByID := map[string]*av.Key{}
for _, keyValues := range attrView.KeyValues {
if nil != keyValues && nil != keyValues.Key {
keysByID[keyValues.Key.ID] = keyValues.Key
}
}
var keys []*av.Key
added := map[string]bool{}
if blockKey := attrView.GetBlockKey(); nil != blockKey {
keys = append(keys, blockKey)
added[blockKey.ID] = true
}
appendKey := func(key *av.Key) {
if nil == key || added[key.ID] || av.KeyTypeLineNumber == key.Type {
return
}
keys = append(keys, key)
added[key.ID] = true
}
for _, keyID := range attrView.KeyIDs {
appendKey(keysByID[keyID])
}
for _, keyValues := range attrView.KeyValues {
if nil != keyValues {
appendKey(keyValues.Key)
}
}
view := &av.View{
ID: ast.NewNodeID(),
Filters: []*av.ViewFilter{},
Sorts: []*av.ViewSort{},
PageSize: av.ViewDefaultPageSize,
LayoutType: av.LayoutTypeTable,
Table: av.NewLayoutTable(),
}
for _, key := range keys {
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{
BaseField: &av.BaseField{ID: key.ID},
})
}
viewable := sql.RenderView(attrView, view, "", false)
ret, _ = viewable.(*av.Table)
return
}
func relationCandidateMatches(row *av.TableRow, keyword, untitled string, columns ...*av.TableColumn) bool {
keywords := strings.Fields(strings.TrimSpace(keyword))
if 1 > len(keywords) {
return true
}
for _, cell := range row.Cells {
if nil == cell || nil == cell.Value {
continue
}
content := cell.Value.String(true)
// 仅匹配主键实际显示的未命名占位文字,不改变字段内容或显示模板的语义。
if cell.ValueType == av.KeyTypeBlock && (cell.Value.Block == nil || cell.Value.Block.Content == "") &&
!cell.Value.HasRenderTemplate && cell.Value.RenderedContent == "" {
hasTemplate := false
for _, column := range columns {
if column.ID == cell.Value.KeyID && strings.TrimSpace(column.RenderTemplate) != "" {
hasTemplate = true
break
}
}
if !hasTemplate {
content = untitled
}
}
allKeywordsHit := true
for _, currentKeyword := range keywords {
if util.SearchCaseSensitive.Load() {
if !strings.Contains(content, currentKeyword) {
allKeywordsHit = false
break
}
} else if !strings.Contains(strings.ToLower(content), strings.ToLower(currentKeyword)) {
allKeywordsHit = false
break
}
}
if allKeywordsHit {
return true
}
}
return false
}
func relationCandidateCreatedAt(row *av.TableRow) int64 {
if nil == row {
return 0
}
blockValue := row.GetBlockValue()
if nil == blockValue {
return 0
}
if 0 < blockValue.CreatedAt {
return blockValue.CreatedAt
}
if nil != blockValue.Block {
return blockValue.Block.Created
}
return 0
}
func GetAttributeViewFilterSort(avID, blockID string) (filters []*av.ViewFilter, sorts []*av.ViewSort) {
waitForSyncingStorages()
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if nil == view || err != nil {
logging.LogErrorf("get current view failed: %s", err)
return
}
filters = view.Filters
sorts = view.Sorts
if 1 > len(filters) {
filters = []*av.ViewFilter{}
}
if 1 > len(sorts) {
sorts = []*av.ViewSort{}
}
return
}
func SearchAttributeViewRollupDestKeys(avID, keyword string) (ret []*av.Key) {
waitForSyncingStorages()
ret = []*av.Key{}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeRollup != keyValues.Key.Type && av.KeyTypeLineNumber != keyValues.Key.Type {
if strings.Contains(strings.ToLower(keyValues.Key.Name), strings.ToLower(keyword)) {
ret = append(ret, keyValues.Key)
}
}
}
return
}
func SearchAttributeViewRelationKey(avID, keyword string) (ret []*av.Key) {
waitForSyncingStorages()
ret = []*av.Key{}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeRelation == keyValues.Key.Type && nil != keyValues.Key.Relation {
if strings.Contains(strings.ToLower(keyValues.Key.Name), strings.ToLower(keyword)) {
ret = append(ret, keyValues.Key)
}
}
}
return
}
func GetAttributeView(avID string) (ret *av.AttributeView) {
waitForSyncingStorages()
ret, _ = av.ParseAttributeView(avID)
return
}
// AttributeViewData 是面向外部接口的兼容数据,不参与数据库文件持久化。
type AttributeViewData struct {
Spec int `json:"spec"`
ID string `json:"id"`
Name string `json:"name"`
CustomColors []*av.AttributeViewCustomColor `json:"customColors"`
KeyValues []*av.KeyValues `json:"keyValues"`
KeyIDs []string `json:"keyIDs"`
ViewID string `json:"viewID"`
Views []*av.View `json:"views"`
NewItemTemplates []*av.NewItemTemplate `json:"newItemTemplates,omitempty"`
DefaultTemplateID string `json:"defaultTemplateID,omitempty"`
Automations *av.AutomationConfig `json:"automations,omitempty"`
CardCoverPositions map[string]map[string]*av.CardCoverPosition `json:"cardCoverPositions,omitempty"`
}
func NewAttributeViewData(attrView *av.AttributeView) (ret *AttributeViewData) {
if nil == attrView {
return
}
ret = &AttributeViewData{
Spec: attrView.Spec, ID: attrView.ID, Name: attrView.Name, KeyValues: attrView.KeyValues, KeyIDs: attrView.KeyIDs,
Views: attrView.Views, NewItemTemplates: attrView.NewItemTemplates, DefaultTemplateID: attrView.DefaultTemplateID,
CardCoverPositions: attrView.CardCoverPositions, CustomColors: attrView.Palette(),
Automations: attrView.Automations,
}
if view, _ := attrView.GetFirstView(); nil != view {
ret.ViewID = view.ID
}
return
}
type AttributeViewFieldView struct {
ID string `json:"id"`
Icon string `json:"icon"`
Name string `json:"name"`
Type av.LayoutType `json:"type"`
Hidden bool `json:"hidden"`
}
func GetAttributeViewFieldViews(avID, keyID string) (ret []*AttributeViewFieldView, err error) {
waitForSyncingStorages()
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
for _, view := range attrView.Views {
field := getAttributeViewField(view, keyID)
if nil == field {
err = fmt.Errorf("field [%s] not found in view [%s]", keyID, view.ID)
return
}
ret = append(ret, &AttributeViewFieldView{
ID: view.ID,
Icon: view.Icon,
Name: view.Name,
Type: view.LayoutType,
Hidden: field.Hidden,
})
}
return
}
type AvSearchResult struct {
AvID string `json:"avID"`
AvName string `json:"avName"`
ViewName string `json:"viewName"`
ViewID string `json:"viewID"`
ViewLayout av.LayoutType `json:"viewLayout"`
BlockID string `json:"blockID"`
HPath string `json:"hPath"`
Matched bool `json:"matched,omitempty"`
Children []*AvSearchResult `json:"children,omitempty"`
}
type AvSearchTempResult struct {
AvID string
AvName string
AvUpdated int64
Score float64
Matched bool
SearchInfo *av.AttributeViewSearchInfo
MatchedViewIDs map[string]bool
}
type SearchAttributeViewOptions struct {
Keyword string
ExcludeAvIDs []string
CurrentAvID string
CurrentBlockID string
IncludeViewMatches bool
}
type attributeViewSearchCacheWarmup struct {
signature uint64
cancel context.CancelFunc
running bool
}
var attributeViewSearchCacheWarmups = struct {
sync.Mutex
states map[string]*attributeViewSearchCacheWarmup
}{states: map[string]*attributeViewSearchCacheWarmup{}}
var attributeViewSearchCacheWarmupDelay = 500 * time.Millisecond
var loadAttributeViewSearchInfo = av.GetAttributeViewSearchInfoInBox
const attributeViewSearchCacheWarmupHashOffset = uint64(1469598103934665603)
const attributeViewSearchCacheWarmupHashPrime = uint64(1099511628211)
func warmAttributeViewSearchCache(boxID string, avIDs []string, signature uint64) {
if len(avIDs) == 0 {
return
}
attributeViewSearchCacheWarmups.Lock()
if state := attributeViewSearchCacheWarmups.states[boxID]; state != nil && state.signature == signature {
attributeViewSearchCacheWarmups.Unlock()
return
}
if state := attributeViewSearchCacheWarmups.states[boxID]; state != nil && state.cancel != nil {
state.cancel()
}
ctx, cancel := context.WithCancel(context.Background())
state := &attributeViewSearchCacheWarmup{signature: signature, cancel: cancel, running: true}
attributeViewSearchCacheWarmups.states[boxID] = state
attributeViewSearchCacheWarmups.Unlock()
ids := slices.Clone(avIDs)
delay := attributeViewSearchCacheWarmupDelay
loader := loadAttributeViewSearchInfo
go func() {
completed := false
defer func() {
attributeViewSearchCacheWarmups.Lock()
defer attributeViewSearchCacheWarmups.Unlock()
if attributeViewSearchCacheWarmups.states[boxID] != state {
return
}
if completed {
state.cancel = nil
state.running = false
} else {
delete(attributeViewSearchCacheWarmups.states, boxID)
}
}()
timer := time.NewTimer(delay)
defer timer.Stop()
select {
case <-ctx.Done():
return
case <-timer.C:
}
for _, avID := range ids {
select {
case <-ctx.Done():
return
default:
}
if isSyncingStorages() {
return
}
_, _ = loader(avID, boxID)
}
completed = true
}()
}
func stopAttributeViewSearchCacheWarmup(boxID string) {
attributeViewSearchCacheWarmups.Lock()
defer attributeViewSearchCacheWarmups.Unlock()
state := attributeViewSearchCacheWarmups.states[boxID]
if state == nil || !state.running {
return
}
state.cancel()
delete(attributeViewSearchCacheWarmups.states, boxID)
}
func updateAttributeViewSearchCacheWarmupSignature(signature uint64, avID string, info os.FileInfo) uint64 {
for i := 0; i < len(avID); i++ {
signature ^= uint64(avID[i])
signature *= attributeViewSearchCacheWarmupHashPrime
}
if info != nil {
signature ^= uint64(info.ModTime().UnixNano())
signature *= attributeViewSearchCacheWarmupHashPrime
signature ^= uint64(info.Size())
signature *= attributeViewSearchCacheWarmupHashPrime
}
return signature
}
func matchAttributeViewSearchName(name string, keywords []string) (score float64, hit bool) {
if name == "" || len(keywords) == 0 {
return
}
lowerName := strings.ToLower(name)
hit = true
for _, keyword := range keywords {
lowerKeyword := strings.ToLower(keyword)
if !strings.Contains(lowerName, lowerKeyword) {
return 0, false
}
score += smetrics.JaroWinkler(name, keyword, 0.7, 4)
}
return
}
func sortAndLimitAttributeViewSearchResults(results []*AvSearchTempResult, keyword string) []*AvSearchTempResult {
if keyword == "" {
sort.Slice(results, func(i, j int) bool { return results[i].AvUpdated > results[j].AvUpdated })
} else {
sort.SliceStable(results, func(i, j int) bool {
if results[i].Score == results[j].Score {
return results[i].AvUpdated > results[j].AvUpdated
}
return results[i].Score > results[j].Score
})
}
if 12 < len(results) {
return results[:12]
}
return results
}
func SearchAttributeView(keyword string, excludeAvIDs []string, currentAvID, currentBlockID string) []*AvSearchResult {
return SearchAttributeViewWithOptions(SearchAttributeViewOptions{
Keyword: keyword,
ExcludeAvIDs: excludeAvIDs,
CurrentAvID: currentAvID,
CurrentBlockID: currentBlockID,
})
}
func SearchAttributeViewWithOptions(options SearchAttributeViewOptions) (ret []*AvSearchResult) {
searchStart := time.Now()
var waitSyncElapsed, readDirElapsed, getBlockRelsElapsed, scanElapsed, readNameElapsed time.Duration
var readFileInfoElapsed, sortElapsed, resolveElapsed, loadTreeElapsed, findNodeElapsed time.Duration
var readSearchInfoElapsed, resolveHPathElapsed time.Duration
var directoryEntryCount, validFileCount, eligibleFileCount, matchedCount int
var readNameCount, loadTreeCount, findNodeCount, readSearchInfoCount, resolveHPathCount int
var eligibleFileSize int64
defer func() {
totalElapsed := time.Since(searchStart)
if totalElapsed < 500*time.Millisecond {
return
}
logging.LogInfof("search attribute views [total=%dms, waitSync=%dms, readDir=%dms, getBlockRels=%dms, scan=%dms, readNames=%dms, readFileInfo=%dms, sort=%dms, resolve=%dms, loadTrees=%dms, findNodes=%dms, readSearchInfo=%dms, resolveHPaths=%dms, entries=%d, validFiles=%d, eligibleFiles=%d, matched=%d, results=%d, readNameCount=%d, loadTreeCount=%d, findNodeCount=%d, readSearchInfoCount=%d, resolveHPathCount=%d, eligibleSizeBytes=%d, keywordEmpty=%t, includeViewMatches=%t]",
totalElapsed.Milliseconds(), waitSyncElapsed.Milliseconds(), readDirElapsed.Milliseconds(),
getBlockRelsElapsed.Milliseconds(), scanElapsed.Milliseconds(), readNameElapsed.Milliseconds(),
readFileInfoElapsed.Milliseconds(), sortElapsed.Milliseconds(), resolveElapsed.Milliseconds(),
loadTreeElapsed.Milliseconds(), findNodeElapsed.Milliseconds(), readSearchInfoElapsed.Milliseconds(),
resolveHPathElapsed.Milliseconds(), directoryEntryCount, validFileCount, eligibleFileCount, matchedCount,
len(ret), readNameCount, loadTreeCount, findNodeCount, readSearchInfoCount, resolveHPathCount,
eligibleFileSize, strings.TrimSpace(options.Keyword) == "", options.IncludeViewMatches)
}()
waitSyncStart := time.Now()
waitForSyncingStorages()
waitSyncElapsed = time.Since(waitSyncStart)
ret = []*AvSearchResult{}
keyword := strings.TrimSpace(options.Keyword)
keywords := strings.Fields(keyword)
var avSearchTmpResults []*AvSearchTempResult
var warmupAvIDs []string
warmupSignature := attributeViewSearchCacheWarmupHashOffset
warmupSignature ^= cache.GetAVCacheGeneration()
warmupSignature *= attributeViewSearchCacheWarmupHashPrime
boxID := ""
if options.CurrentBlockID != "" {
if bt := treenode.GetBlockTree(options.CurrentBlockID); nil != bt && IsEncryptedBox(bt.BoxID) {
boxID = bt.BoxID
}
} else if options.CurrentAvID != "" {
_, boxID = av.FindAttributeViewPath(options.CurrentAvID)
}
if keyword != "" {
stopAttributeViewSearchCacheWarmup(boxID)
}
avDir := filepath.Join(util.DataDir, "storage", "av")
if boxID != "" {
avDir = filepath.Join(util.DataDir, boxID, "storage", "av")
}
readDirStart := time.Now()
entries, err := os.ReadDir(avDir)
readDirElapsed = time.Since(readDirStart)
if err != nil {
logging.LogErrorf("read directory [%s] failed: %s", avDir, err)
return
}
directoryEntryCount = len(entries)
getBlockRelsStart := time.Now()
avBlockRels := av.GetBlockRels()
getBlockRelsElapsed = time.Since(getBlockRelsStart)
if 1 > len(avBlockRels) {
return
}
scanStart := time.Now()
for _, entry := range entries {
if entry.IsDir() {
continue
}
id := strings.TrimSuffix(entry.Name(), ".json")
if !ast.IsNodeIDPattern(id) {
continue
}
validFileCount++
if nil == avBlockRels[id] {
continue
}
readFileInfoStart := time.Now()
info, _ := entry.Info()
readFileInfoElapsed += time.Since(readFileInfoStart)
warmupAvIDs = append(warmupAvIDs, id)
warmupSignature = updateAttributeViewSearchCacheWarmupSignature(warmupSignature, id, info)
if gulu.Str.Contains(id, options.ExcludeAvIDs) {
continue
}
eligibleFileCount++
if info != nil {
eligibleFileSize += info.Size()
}
a := &AvSearchTempResult{AvID: id}
if nil != info && !info.ModTime().IsZero() {
a.AvUpdated = info.ModTime().UnixMilli()
}
if keyword == "" {
avSearchTmpResults = append(avSearchTmpResults, a)
continue
}
var searchInfo *av.AttributeViewSearchInfo
readSearchInfoStart := time.Now()
searchInfo, _ = av.GetAttributeViewSearchInfoInBox(id, boxID)
readSearchInfoElapsed += time.Since(readSearchInfoStart)
readSearchInfoCount++
var name string
if searchInfo != nil {
name = searchInfo.Name
}
if searchInfo == nil {
readNameStart := time.Now()
name, _ = av.GetAttributeViewNameInBox(id, boxID)
readNameElapsed += time.Since(readNameStart)
readNameCount++
}
score, hit := matchAttributeViewSearchName(name, keywords)
matchedViewIDs := map[string]bool{}
if options.IncludeViewMatches && searchInfo != nil {
for _, view := range searchInfo.Views {
viewScore, viewHit := matchAttributeViewSearchName(view.Name, keywords)
if viewHit {
matchedViewIDs[view.ID] = true
if viewScore > score {
score = viewScore
}
}
}
}
if hit || len(matchedViewIDs) > 0 {
a.AvName = name
a.Score = score
a.Matched = hit
a.SearchInfo = searchInfo
a.MatchedViewIDs = matchedViewIDs
avSearchTmpResults = append(avSearchTmpResults, a)
}
}
scanElapsed = time.Since(scanStart)
sortStart := time.Now()
matchedCount = len(avSearchTmpResults)
avSearchTmpResults = sortAndLimitAttributeViewSearchResults(avSearchTmpResults, keyword)
sortElapsed = time.Since(sortStart)
resolveStart := time.Now()
for _, tmpResult := range avSearchTmpResults {
bIDs := avBlockRels[tmpResult.AvID]
var node *ast.Node
var treeHPath string
for _, bID := range bIDs {
loadTreeStart := time.Now()
// 数据库块关系可能因删除、同步或索引尚未完成而暂时失效,搜索时静默跳过。
tree, _ := loadTreeByBlockIDInBox0(bID, boxID, false)
loadTreeElapsed += time.Since(loadTreeStart)
loadTreeCount++
if nil == tree {
continue
}
findNodeStart := time.Now()
node = treenode.GetNodeInTree(tree, bID)
findNodeElapsed += time.Since(findNodeStart)
findNodeCount++
if nil == node || "" == node.AttributeViewID || ast.NodeAttributeView != node.Type {
node = nil
continue
}
treeHPath = tree.HPath
break
}
if nil == node {
continue
}
searchInfo := tmpResult.SearchInfo
if searchInfo == nil {
readSearchInfoStart := time.Now()
searchInfo, _ = av.GetAttributeViewSearchInfoInBox(tmpResult.AvID, boxID)
readSearchInfoElapsed += time.Since(readSearchInfoStart)
readSearchInfoCount++
}
if searchInfo == nil {
continue
}
if tmpResult.AvName == "" {
tmpResult.AvName = searchInfo.Name
}
resolveHPathStart := time.Now()
hPath := treeHPath
box := Conf.Box(node.Box)
if nil != box {
hPath = box.Name + hPath
}
resolveHPathElapsed += time.Since(resolveHPathStart)
resolveHPathCount++
parent := &AvSearchResult{
AvID: tmpResult.AvID,
AvName: tmpResult.AvName,
BlockID: node.ID,
HPath: hPath,
Matched: tmpResult.Matched,
}
ret = append(ret, parent)
for _, view := range searchInfo.Views {
child := &AvSearchResult{
AvID: tmpResult.AvID,
AvName: tmpResult.AvName,
ViewName: view.Name,
ViewID: view.ID,
ViewLayout: view.LayoutType,
BlockID: node.ID,
HPath: hPath,
Matched: tmpResult.MatchedViewIDs[view.ID],
}
parent.Children = append(parent.Children, child)
}
}
resolveElapsed = time.Since(resolveStart)
if keyword == "" {
warmAttributeViewSearchCache(boxID, warmupAvIDs, warmupSignature)
}
return
}
type BlockAttributeViewKeys struct {
AvID string `json:"avID"`
AvName string `json:"avName"`
CustomColors []*av.AttributeViewCustomColor `json:"customColors"`
BlockIDs []string `json:"blockIDs"`
KeyValues []*av.KeyValues `json:"keyValues"`
ItemPositions []*AttributeViewItemPosition `json:"itemPositions"`
}
type AttributeViewItemPosition struct {
ViewID string `json:"viewID"`
PreviousID string `json:"previousID"`
Groups []*AttributeViewGroupItemPosition `json:"groups"`
}
type AttributeViewGroupItemPosition struct {
GroupID string `json:"groupID"`
PreviousID string `json:"previousID"`
}
func getAttributeViewItemPositions(attrView *av.AttributeView, itemID string) (ret []*AttributeViewItemPosition) {
for _, view := range attrView.Views {
previousID, found := getAttributeViewPreviousItemID(view.ItemIDs, itemID)
if !found {
continue
}
position := &AttributeViewItemPosition{ViewID: view.ID, PreviousID: previousID}
for _, group := range view.Groups {
groupPreviousID, groupFound := getAttributeViewPreviousItemID(group.GroupItemIDs, itemID)
if groupFound {
position.Groups = append(position.Groups, &AttributeViewGroupItemPosition{
GroupID: group.ID, PreviousID: groupPreviousID,
})
}
}
ret = append(ret, position)
}
return
}
func getAttributeViewPreviousItemID(itemIDs []string, itemID string) (previousID string, found bool) {
for i, currentID := range itemIDs {
if currentID != itemID {
continue
}
if 0 < i {
previousID = itemIDs[i-1]
}
found = true
return
}
return
}
type AttributeViewBacklinkRelation struct {
KeyID string `json:"keyID"`
KeyName string `json:"keyName"`
TargetAvID string `json:"targetAvID"`
TargetItemID string `json:"targetItemID"`
}
type AttributeViewBacklink struct {
AvID string `json:"avID"`
AvName string `json:"avName"`
BlockIDs []string `json:"blockIDs"`
DatabaseBlockID string `json:"databaseBlockID"`
BoxID string `json:"boxID"`
DatabasePath string `json:"databasePath"`
ItemID string `json:"itemID"`
ValueID string `json:"valueID"`
Title string `json:"title"`
Icon string `json:"icon"`
BoundBlockID string `json:"boundBlockID"`
IsDetached bool `json:"isDetached"`
Relations []*AttributeViewBacklinkRelation `json:"relations"`
}
type AttributeViewBacklinks struct {
Total int `json:"total"`
Items []*AttributeViewBacklink `json:"items"`
}
type attributeViewBacklinkTarget struct {
avID string
itemID string
}
func getAttributeViewBacklinkMatches(srcAttrView *av.AttributeView, target *attributeViewBacklinkTarget) (ret map[string][]*AttributeViewBacklinkRelation) {
ret = map[string][]*AttributeViewBacklinkRelation{}
seenRelations := map[string]bool{}
for _, keyValues := range srcAttrView.KeyValues {
key := keyValues.Key
if av.KeyTypeRelation != key.Type || nil == key.Relation || key.Relation.AvID != target.avID {
continue
}
for _, value := range keyValues.Values {
if nil == value.Relation || !slices.Contains(value.Relation.BlockIDs, target.itemID) {
continue
}
relationID := value.BlockID + "\x00" + key.ID + "\x00" + target.avID + "\x00" + target.itemID
if seenRelations[relationID] {
continue
}
seenRelations[relationID] = true
ret[value.BlockID] = append(ret[value.BlockID], &AttributeViewBacklinkRelation{
KeyID: key.ID,
KeyName: key.Name,
TargetAvID: target.avID,
TargetItemID: target.itemID,
})
}
}
return
}
func getAttributeViewBacklinkBlockValues(attrView *av.AttributeView) (ret map[string]*av.Value) {
ret = map[string]*av.Value{}
blockKeyValues := attrView.GetBlockKeyValues()
if nil == blockKeyValues {
return
}
for _, value := range blockKeyValues.Values {
ret[value.BlockID] = value
}
return
}
func resolveAttributeViewBacklinkItemID(attrView *av.AttributeView, itemID, valueID string) string {
if nil != attrView.GetBlockValue(itemID) {
return itemID
}
if "" == valueID {
return ""
}
for _, value := range getAttributeViewBacklinkBlockValues(attrView) {
if value.ID == valueID {
return value.BlockID
}
}
return ""
}
func sortAttributeViewBacklinkBlockIDs(blockIDs []string, blockTrees map[string]*treenode.BlockTree) {
sort.Slice(blockIDs, func(i, j int) bool {
left, right := blockTrees[blockIDs[i]], blockTrees[blockIDs[j]]
if nil == left || nil == right {
if nil == left && nil != right {
return false
}
if nil != left && nil == right {
return true
}
return blockIDs[i] < blockIDs[j]
}
if left.HPath != right.HPath {
return left.HPath < right.HPath
}
if left.BoxID != right.BoxID {
return left.BoxID < right.BoxID
}
return blockIDs[i] < blockIDs[j]
})
}
func GetAttributeViewBacklinks(nodeID, avID, itemID, valueID string) (ret *AttributeViewBacklinks) {
waitForSyncingStorages()
ret = &AttributeViewBacklinks{Items: []*AttributeViewBacklink{}}
targets := getAttributeViewBacklinkTargets(nodeID, avID, itemID, valueID)
if 1 > len(targets) {
return
}
backlinks := map[string]*AttributeViewBacklink{}
relationKeys := map[string]map[string]bool{}
cachedAttrViews := map[string]*av.AttributeView{}
cachedBlockValues := map[string]map[string]*av.Value{}
cachedBlockIDs := map[string][]string{}
cachedBlockTrees := map[string]map[string]*treenode.BlockTree{}
for _, target := range targets {
for _, srcAvID := range av.GetSrcAvIDs(target.avID) {
srcAttrView := cachedAttrViews[srcAvID]
if nil == srcAttrView {
var err error
srcAttrView, err = av.ParseAttributeView(srcAvID)
if nil == srcAttrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", srcAvID, err)
continue
}
cachedAttrViews[srcAvID] = srcAttrView
}
blockValues := cachedBlockValues[srcAvID]
if nil == blockValues {
blockValues = getAttributeViewBacklinkBlockValues(srcAttrView)
cachedBlockValues[srcAvID] = blockValues
}
for sourceItemID, relations := range getAttributeViewBacklinkMatches(srcAttrView, target) {
blockValue := blockValues[sourceItemID]
if nil == blockValue || nil == blockValue.Block {
continue
}
backlinkID := srcAvID + "\x00" + sourceItemID
backlink := backlinks[backlinkID]
if nil == backlink {
blockIDs, cached := cachedBlockIDs[srcAvID]
blockTrees := cachedBlockTrees[srcAvID]
if !cached {
blockIDs = treenode.GetMirrorAttrViewBlockIDs(srcAvID)
blockTrees = treenode.GetBlockTrees(blockIDs)
sortAttributeViewBacklinkBlockIDs(blockIDs, blockTrees)
cachedBlockIDs[srcAvID] = blockIDs
cachedBlockTrees[srcAvID] = blockTrees
}
backlink = &AttributeViewBacklink{
AvID: srcAvID,
AvName: getAttrViewName(srcAttrView),
BlockIDs: blockIDs,
ItemID: sourceItemID,
ValueID: blockValue.ID,
Title: blockValue.Block.Content,
Icon: blockValue.Block.Icon,
BoundBlockID: blockValue.Block.ID,
IsDetached: blockValue.IsDetached || "" == blockValue.Block.ID,
Relations: []*AttributeViewBacklinkRelation{},
}
if 0 < len(blockIDs) {
backlink.DatabaseBlockID = blockIDs[0]
if bt := blockTrees[blockIDs[0]]; nil != bt {
backlink.BoxID = bt.BoxID
backlink.DatabasePath = bt.HPath
}
}
backlinks[backlinkID] = backlink
relationKeys[backlinkID] = map[string]bool{}
}
for _, relation := range relations {
relationID := relation.KeyID + "\x00" + relation.TargetAvID + "\x00" + relation.TargetItemID
if relationKeys[backlinkID][relationID] {
continue
}
relationKeys[backlinkID][relationID] = true
backlink.Relations = append(backlink.Relations, relation)
}
}
}
}
for _, backlink := range backlinks {
ret.Items = append(ret.Items, backlink)
}
sort.Slice(ret.Items, func(i, j int) bool {
if ret.Items[i].AvName != ret.Items[j].AvName {
return ret.Items[i].AvName < ret.Items[j].AvName
}
if ret.Items[i].Title != ret.Items[j].Title {
return ret.Items[i].Title < ret.Items[j].Title
}
return ret.Items[i].ItemID < ret.Items[j].ItemID
})
ret.Total = len(ret.Items)
return
}
func getAttributeViewBacklinkTargets(nodeID, avID, itemID, valueID string) (ret []*attributeViewBacklinkTarget) {
if "" != avID && ("" != itemID || "" != valueID) {
attrView, err := av.ParseAttributeView(avID)
if nil == attrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
itemID = resolveAttributeViewBacklinkItemID(attrView, itemID, valueID)
if "" != itemID {
ret = append(ret, &attributeViewBacklinkTarget{avID: avID, itemID: itemID})
}
return
}
attrs := sql.GetBlockAttrs(nodeID)
for targetAvID := range strings.SplitSeq(attrs[av.NodeAttrNameAvs], ",") {
if "" == targetAvID {
continue
}
attrView, err := av.ParseAttributeView(targetAvID)
if nil == attrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", targetAvID, err)
continue
}
blockValue := attrView.GetBlockValueByBoundID(nodeID)
if nil != blockValue {
ret = append(ret, &attributeViewBacklinkTarget{avID: targetAvID, itemID: blockValue.BlockID})
}
}
return
}
func GetAttributeViewItemKeys(avID, itemID, valueID string) (ret []*BlockAttributeViewKeys) {
waitForSyncingStorages()
ret = []*BlockAttributeViewKeys{}
attrView, err := av.ParseAttributeView(avID)
if nil == attrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
if nil == attrView.GetBlockValue(itemID) && "" != valueID {
blockKeyValues := attrView.GetBlockKeyValues()
if nil != blockKeyValues {
for _, value := range blockKeyValues.Values {
if value.ID == valueID {
itemID = value.BlockID
break
}
}
}
}
if nil == attrView.GetBlockValue(itemID) {
return
}
view, err := getRenderAttributeViewView(attrView, "", "", "", true)
if nil != err {
return
}
viewable := sql.RenderView(attrView, view, "", false)
collection, ok := viewable.(av.Collection)
if !ok {
return
}
keyValues := getAttributeViewItemKeyValues(attrView, collection, itemID, false)
refreshAttrViewKeyIDs(attrView, true)
sorts := map[string]int{}
for i, keyID := range attrView.KeyIDs {
sorts[keyID] = i
}
sort.Slice(keyValues, func(i, j int) bool {
return sorts[keyValues[i].Key.ID] < sorts[keyValues[j].Key.ID]
})
ret = append(ret, &BlockAttributeViewKeys{
AvID: avID,
AvName: getAttrViewName(attrView),
CustomColors: attrView.Palette(),
BlockIDs: treenode.GetMirrorAttrViewBlockIDs(avID),
KeyValues: keyValues,
ItemPositions: getAttributeViewItemPositions(attrView, itemID),
})
return
}
func GetBlockAttributeViewKeys(nodeID string) (ret []*BlockAttributeViewKeys) {
waitForSyncingStorages()
ret = []*BlockAttributeViewKeys{}
attrs := sql.GetBlockAttrs(nodeID)
avs := attrs[av.NodeAttrNameAvs]
if "" == avs {
return
}
cachedAttrViews := map[string]*av.AttributeView{}
avIDs := strings.SplitSeq(avs, ",")
for avID := range avIDs {
attrView := cachedAttrViews[avID]
if nil == attrView {
var err error
attrView, err = av.ParseAttributeView(avID)
if nil == attrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
continue
}
cachedAttrViews[avID] = attrView
}
if !attrView.ExistBoundBlock(nodeID) {
// 比如剪切后粘贴,块 ID 会变,但是属性还在块上,这里做一次数据订正
// Auto verify the database name when clicking the block superscript icon https://github.com/siyuan-note/siyuan/issues/10861
unbindBlockAv(nil, avID, nodeID)
return
}
blockVal := attrView.GetBlockValueByBoundID(nodeID)
if nil == blockVal {
continue
}
itemID := blockVal.BlockID
view, err := getRenderAttributeViewView(attrView, "", "", nodeID, true)
if nil != err {
continue
}
viewable := sql.RenderView(attrView, view, "", false)
collection, ok := viewable.(av.Collection)
if !ok {
continue
}
keyValues := getAttributeViewItemKeyValues(attrView, collection, itemID, true)
// 字段排序
refreshAttrViewKeyIDs(attrView, true)
sorts := map[string]int{}
for i, k := range attrView.KeyIDs {
sorts[k] = i
}
sort.Slice(keyValues, func(i, j int) bool {
return sorts[keyValues[i].Key.ID] < sorts[keyValues[j].Key.ID]
})
blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
if 1 > len(blockIDs) {
// 老数据兼容处理
boxID := ""
if tree, _ := LoadTreeByBlockID(nodeID); tree != nil {
boxID = tree.Box
}
avBts := treenode.GetBlockTreesByTypeInBox("av", boxID)
for _, avBt := range avBts {
if nil == avBt {
continue
}
tree, _ := LoadTreeByBlockIDInExactBox(avBt.ID, avBt.BoxID)
if nil == tree {
continue
}
node := treenode.GetNodeInTree(tree, avBt.ID)
if nil == node {
continue
}
if avID == node.AttributeViewID {
blockIDs = append(blockIDs, avBt.ID)
}
}
if 1 > len(blockIDs) {
tree, _ := LoadTreeByBlockID(nodeID)
if nil != tree {
node := treenode.GetNodeInTree(tree, nodeID)
if nil != node {
if removeErr := removeNodeAvID(node, avID, nil, tree); nil != removeErr {
logging.LogErrorf("remove node avID [%s] failed: %s", avID, removeErr)
}
}
}
continue
}
blockIDs = gulu.Str.RemoveDuplicatedElem(blockIDs)
for _, blockID := range blockIDs {
av.UpsertBlockRel(avID, blockID)
}
}
ret = append(ret, &BlockAttributeViewKeys{
AvID: avID,
AvName: getAttrViewName(attrView),
CustomColors: attrView.Palette(),
BlockIDs: blockIDs,
KeyValues: keyValues,
ItemPositions: getAttributeViewItemPositions(attrView, itemID),
})
}
return
}
func getAttributeViewItemKeyValues(attrView *av.AttributeView, collection av.Collection, itemID string,
includeEmpty bool) (ret []*av.KeyValues) {
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeLineNumber == keyValues.Key.Type {
continue
}
itemKeyValues := &av.KeyValues{Key: keyValues.Key}
if value := collection.GetValue(itemID, keyValues.Key.ID); nil != value {
itemKeyValues.Values = append(itemKeyValues.Values, value)
} else {
for _, value := range keyValues.Values {
if value.BlockID == itemID {
itemKeyValues.Values = append(itemKeyValues.Values, value)
}
}
}
if includeEmpty || 0 < len(itemKeyValues.Values) {
ret = append(ret, itemKeyValues)
}
}
return
}
func genAttrViewGroups(view *av.View, attrView *av.AttributeView) {
if !view.IsGroupView() {
return
}
viewable := sql.RenderView(attrView, view, "", false)
genAttrViewGroupsWithItems(view, attrView, viewable.(av.Collection).GetItems())
}
func genAttrViewGroupsWithItems(view *av.View, attrView *av.AttributeView, sourceItems []av.Item) {
if !view.IsGroupView() {
return
}
groupStates := getAttrViewGroupStates(view)
group := view.Group
view.Groups = nil
items := append([]av.Item(nil), sourceItems...)
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
return
}
groupByRendered := av.ValueSourceRendered == group.ValueSource
groupMethod := group.Method
if groupByRendered {
// 显示模板结果按文本值分组,不应用源字段的数字或日期分组方法。
groupMethod = av.GroupMethodValue
}
getGroupValue := func(item av.Item) *av.Value {
return av.ResolveValueSource(item.GetValue(group.Field), group.ValueSource)
}
var rangeStart, rangeEnd float64
switch groupMethod {
case av.GroupMethodValue:
if av.GroupOrderMan != group.Order {
sort.SliceStable(items, func(i, j int) bool {
return getGroupValue(items[i]).String(false) < getGroupValue(items[j]).String(false)
})
}
case av.GroupMethodRangeNum:
if nil == group.Range {
return
}
rangeStart, rangeEnd = group.Range.NumStart, group.Range.NumStart+group.Range.NumStep
sort.SliceStable(items, func(i, j int) bool {
return items[i].GetValue(group.Field).Number.Content < items[j].GetValue(group.Field).Number.Content
})
case av.GroupMethodDateDay, av.GroupMethodDateWeek, av.GroupMethodDateMonth, av.GroupMethodDateYear, av.GroupMethodDateRelative:
if av.KeyTypeCreated == groupKey.Type {
sort.SliceStable(items, func(i, j int) bool {
return items[i].GetValue(group.Field).Created.Content < items[j].GetValue(group.Field).Created.Content
})
} else if av.KeyTypeUpdated == groupKey.Type {
sort.SliceStable(items, func(i, j int) bool {
return items[i].GetValue(group.Field).Updated.Content < items[j].GetValue(group.Field).Updated.Content
})
} else if av.KeyTypeDate == groupKey.Type {
sort.SliceStable(items, func(i, j int) bool {
return items[i].GetValue(group.Field).Date.Content < items[j].GetValue(group.Field).Date.Content
})
}
}
todayStart := time.Now()
todayStart = time.Date(todayStart.Year(), todayStart.Month(), todayStart.Day(), 0, 0, 0, 0, time.Local)
var relationDestAv *av.AttributeView
if !groupByRendered && av.KeyTypeRelation == groupKey.Type && nil != groupKey.Relation {
if attrView.ID == groupKey.Relation.AvID {
relationDestAv = attrView
} else {
relationDestAv, _ = av.ParseAttributeView(groupKey.Relation.AvID)
}
}
groupItemsMap := map[string][]av.Item{}
for _, item := range items {
value := getGroupValue(item)
if value.IsBlank() {
groupItemsMap[groupValueDefault] = append(groupItemsMap[groupValueDefault], item)
continue
}
var groupVal string
switch groupMethod {
case av.GroupMethodValue:
if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
for _, s := range value.MSelect {
groupItemsMap[s.Content] = append(groupItemsMap[s.Content], item)
}
continue
} else if !groupByRendered && av.KeyTypeRelation == groupKey.Type {
if nil == relationDestAv {
continue
}
for _, bID := range value.Relation.BlockIDs {
groupItemsMap[bID] = append(groupItemsMap[bID], item)
}
continue
}
groupVal = value.String(false)
case av.GroupMethodRangeNum:
if group.Range.NumStart > value.Number.Content || group.Range.NumEnd < value.Number.Content {
groupVal = groupValueNotInRange
break
}
for rangeEnd <= group.Range.NumEnd && rangeEnd <= value.Number.Content {
rangeStart += group.Range.NumStep
rangeEnd += group.Range.NumStep
}
if rangeStart <= value.Number.Content && rangeEnd > value.Number.Content {
groupVal = fmt.Sprintf("%s - %s", strconv.FormatFloat(rangeStart, 'f', -1, 64), strconv.FormatFloat(rangeEnd, 'f', -1, 64))
}
case av.GroupMethodDateDay, av.GroupMethodDateWeek, av.GroupMethodDateMonth, av.GroupMethodDateYear, av.GroupMethodDateRelative:
var contentTime time.Time
switch value.Type {
case av.KeyTypeDate:
contentTime = time.UnixMilli(value.Date.Content)
case av.KeyTypeCreated:
contentTime = time.UnixMilli(value.Created.Content)
case av.KeyTypeUpdated:
contentTime = time.UnixMilli(value.Updated.Content)
}
switch groupMethod {
case av.GroupMethodDateDay:
groupVal = contentTime.Format("2006-01-02")
case av.GroupMethodDateWeek:
year, week := contentTime.ISOWeek()
groupVal = fmt.Sprintf("%d-W%02d", year, week)
case av.GroupMethodDateMonth:
groupVal = contentTime.Format("2006-01")
case av.GroupMethodDateYear:
groupVal = contentTime.Format("2006")
case av.GroupMethodDateRelative:
// 过去 30 天之前的按月分组
// 过去 30 天、过去 7 天、昨天、今天、明天、未来 7 天、未来 30 天
// 未来 30 天之后的按月分组
if contentTime.Before(todayStart.AddDate(0, 0, -30)) {
groupVal = contentTime.Format("2006-01") // 开头的数字用于排序
} else if contentTime.Before(todayStart.AddDate(0, 0, -7)) {
groupVal = groupValueLast30Days
} else if contentTime.Before(todayStart.AddDate(0, 0, -1)) {
groupVal = groupValueLast7Days
} else if contentTime.Before(todayStart) {
groupVal = groupValueYesterday
} else if (contentTime.After(todayStart) || contentTime.Equal(todayStart)) && contentTime.Before(todayStart.AddDate(0, 0, 1)) {
groupVal = groupValueToday
} else if contentTime.After(todayStart.AddDate(0, 0, 30)) {
groupVal = contentTime.Format("2006-01")
} else if contentTime.After(todayStart.AddDate(0, 0, 7)) {
groupVal = groupValueNext30Days
} else if contentTime.Equal(todayStart.AddDate(0, 0, 2)) || contentTime.After(todayStart.AddDate(0, 0, 2)) {
groupVal = groupValueNext7Days
} else {
groupVal = groupValueTomorrow
}
}
}
groupItemsMap[groupVal] = append(groupItemsMap[groupVal], item)
}
if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
for _, o := range groupKey.Options {
if _, ok := groupItemsMap[o.Name]; !ok {
groupItemsMap[o.Name] = []av.Item{}
}
}
}
if groupByRendered || av.KeyTypeCheckbox != groupKey.Type {
if 1 > len(groupItemsMap[groupValueDefault]) {
// 始终保留默认分组 https://github.com/siyuan-note/siyuan/issues/15587
groupItemsMap[groupValueDefault] = []av.Item{}
}
} else {
// 对于复选框分组,空白分组表示未选中状态,始终保留 https://github.com/siyuan-note/siyuan/issues/15650
if nil == groupItemsMap[""] {
groupItemsMap[""] = []av.Item{}
}
if nil == groupItemsMap[av.CheckboxCheckedStr] {
groupItemsMap[av.CheckboxCheckedStr] = []av.Item{}
}
}
groupValues := make([]string, 0, len(groupItemsMap))
for value := range groupItemsMap {
groupValues = append(groupValues, value)
}
sort.Strings(groupValues)
for _, groupValue := range groupValues {
groupItems := groupItemsMap[groupValue]
var v *av.View
switch view.LayoutType {
case av.LayoutTypeList:
v = av.NewListView()
case av.LayoutTypeTable:
v = av.NewTableView()
v.Table = av.NewLayoutTable()
case av.LayoutTypeGallery:
v = av.NewGalleryView()
v.Gallery = av.NewLayoutGallery()
case av.LayoutTypeKanban:
v = av.NewKanbanView()
v.Kanban = av.NewLayoutKanban()
default:
logging.LogWarnf("unknown layout type [%s] for group view", view.LayoutType)
return
}
v.GroupItemIDs = []string{}
for _, item := range groupItems {
v.GroupItemIDs = append(v.GroupItemIDs, item.GetID())
}
v.Name = "" // 分组视图的名称在渲染时才填充
v.GroupHidden = 1 // 默认隐藏空白分组
v.GroupKey = groupKey
v.GroupVal = &av.Value{Type: av.KeyTypeText, Text: &av.ValueText{Content: groupValue}}
if !groupByRendered && (av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type) {
if opt := groupKey.GetOption(groupValue); nil != opt {
v.GroupVal.Text = nil
v.GroupVal.Type = av.KeyTypeSelect
v.GroupVal.MSelect = []*av.ValueSelect{newAttrViewValueSelect(opt)}
}
} else if !groupByRendered && av.KeyTypeRelation == groupKey.Type {
if relationDestAv != nil && groupValueDefault != groupValue {
v.GroupVal.Text = nil
v.GroupVal.Type = av.KeyTypeRelation
v.GroupVal.Relation = &av.ValueRelation{BlockIDs: []string{groupValue}}
if destBlock := relationDestAv.GetBlockValue(groupValue); nil != destBlock {
v.GroupVal.Relation.Contents = []*av.Value{destBlock}
}
}
} else if !groupByRendered && av.KeyTypeCheckbox == groupKey.Type {
v.GroupVal.Text = nil
v.GroupVal.Type = av.KeyTypeCheckbox
v.GroupVal.Checkbox = &av.ValueCheckbox{}
if "" != groupValue {
v.GroupVal.Checkbox.Checked = true
}
}
v.GroupSort = -1
view.Groups = append(view.Groups, v)
}
view.GroupCreated = time.Now().UnixMilli()
setAttrViewGroupStates(view, groupStates)
}
// GroupState 用于临时记录每个分组视图的状态,以便后面重新生成分组后可以恢复这些状态。
type GroupState struct {
ID string
LayoutID string
LayoutType av.LayoutType
Position int
Folded bool
Hidden int
Sort int
ItemIDs []string
}
func getAttrViewGroupStates(view *av.View) (groupStates map[string]*GroupState) {
groupStates = map[string]*GroupState{}
if !view.IsGroupView() {
return
}
for position, groupView := range view.Groups {
if av.LayoutTypeKanban == groupView.LayoutType {
// 看板视图的分组不能折叠
groupView.GroupFolded = false
}
groupStates[groupView.GetGroupValue()] = &GroupState{
ID: groupView.ID,
LayoutID: attrViewGroupLayoutID(groupView),
LayoutType: groupView.LayoutType,
Position: position,
Folded: groupView.GroupFolded,
Hidden: groupView.GroupHidden,
Sort: groupView.GroupSort,
ItemIDs: groupView.GroupItemIDs,
}
}
return
}
func setAttrViewGroupStates(view *av.View, groupStates map[string]*GroupState) {
for _, groupView := range view.Groups {
if state, ok := groupStates[groupView.GetGroupValue()]; ok {
groupView.ID = state.ID
groupView.GroupFolded = state.Folded
groupView.GroupHidden = state.Hidden
groupView.GroupSort = state.Sort
if groupView.LayoutType == state.LayoutType && state.LayoutID != "" {
if layout := groupView.GetBaseLayout(); nil != layout {
layout.ID = state.LayoutID
}
}
itemIDsSort := map[string]int{}
for i, itemID := range state.ItemIDs {
itemIDsSort[itemID] = i
}
sort.SliceStable(groupView.GroupItemIDs, func(i, j int) bool {
return itemIDsSort[groupView.GroupItemIDs[i]] < itemIDsSort[groupView.GroupItemIDs[j]]
})
}
}
// 分组重建保留序列化顺序,避免未编辑的布局被记录为字段变更。
sort.SliceStable(view.Groups, func(i, j int) bool {
left, right := groupStates[view.Groups[i].GetGroupValue()], groupStates[view.Groups[j].GetGroupValue()]
if left != nil && right != nil {
return left.Position < right.Position
}
return left != nil && right == nil
})
defaultGroup := view.GetGroupByGroupValue(groupValueDefault)
if nil != defaultGroup {
if -1 == defaultGroup.GroupSort {
view.RemoveGroupByID(defaultGroup.ID)
} else {
defaultGroup = nil
}
}
for i, groupView := range view.Groups {
if i != groupView.GroupSort && -1 == groupView.GroupSort {
groupView.GroupSort = i
}
}
if nil != defaultGroup {
view.Groups = append(view.Groups, defaultGroup)
defaultGroup.GroupSort = len(view.Groups) - 1
}
}
// attrViewGroupLayoutID 返回可分组的布局 ID,日历不参与分组。
func attrViewGroupLayoutID(view *av.View) string {
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeGallery, av.LayoutTypeKanban:
if layout := view.GetBaseLayout(); nil != layout {
return layout.ID
}
}
return ""
}
func GetCurrentAttributeViewImages(c *gin.Context, avID, blockID, viewID, query, groupID string) (ret []string, err error) {
var attrView *av.AttributeView
attrView, err = avParseView(avID, blockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
// 发布读者只能读取发布可访问数据库中的图片。逐行过滤会把游离行视为可访问,缺少数据库级门禁时会泄漏未授权
// 数据库游离行的图片资源路径,因此这里与 renderAttributeView 保持一致,在提取资源前做顶层访问校验。
if IsReadOnlyRoleContext(c) {
if !CheckAttributeViewBlockAccessableByPublishAccess(c, GetPublishAccess(), avID, blockID) {
err = av.ErrAttributeViewNotFound
return
}
}
var view *av.View
view, err = resolveAttributeViewView(attrView, viewID, "", blockID)
if nil != err {
return
}
filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, blockID)
if nil != contextErr {
err = contextErr
return
}
imageView := view
if groupID != "" {
// 动态分组沿用界面渲染的刷新规则,仅在内存中更新,不写入数据库。
if view.Groups == nil || isGroupByTemplate(attrView, view) ||
(isGroupByDate(view) && time.UnixMilli(view.GroupCreated).Format("2006-01-02") != time.Now().Format("2006-01-02")) {
genAttrViewGroups(view, attrView)
}
group := view.GetGroupByID(groupID)
if !view.IsGroupView() || group == nil {
return nil, av.ErrViewNotFound
}
// 保留父视图字段、筛选及排序,使用分组条目集合和组内手动顺序。
groupView := *view
groupView.ID = group.ID
groupView.GroupItemIDs = append([]string{}, group.GroupItemIDs...)
// 分组生成可能缓存父视图,图片列表需要独立执行当前分组的搜索和筛选。
delete(attrView.RenderedViewables, group.ID)
imageView = &groupView
}
cachedAttrViews := map[string]*av.AttributeView{}
rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
table := getAttrViewTable(attrView, imageView, query)
av.FilterWithContext(table, attrView, rollupFurtherCollections, cachedAttrViews, filterContext)
av.Sort(table, attrView)
if IsReadOnlyRoleContext(c) {
// 顶层门禁已通过,这里再按行剔除绑定在不可发布文档中的行值
table = FilterViewByPublishAccess(c, GetPublishAccess(), table).(*av.Table)
}
ids := map[string]bool{}
for _, column := range table.Columns {
ids[column.ID] = column.Hidden
}
for _, row := range table.Rows {
for _, cell := range row.Cells {
if nil != cell.Value && av.KeyTypeMAsset == cell.Value.Type && nil != cell.Value.MAsset && !ids[cell.Value.KeyID] {
for _, a := range cell.Value.MAsset {
if av.AssetTypeImage == a.Type {
ret = append(ret, a.Content)
}
}
}
}
}
return
}
func (tx *Transaction) doSetAttrViewColDateFillCreated(operation *Operation) (ret *TxErr) {
err := setAttributeViewColDateFillCreated(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColDateFillCreated(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
keyID := operation.ID
key, _ := attrView.GetKey(keyID)
if nil == key || av.KeyTypeDate != key.Type {
return
}
if nil == key.Date {
key.Date = &av.Date{}
}
key.Date.AutoFillNow = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColDateFillSpecificTime(operation *Operation) (ret *TxErr) {
err := setAttrViewColDateFillSpecificTime(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewColDateFillSpecificTime(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
keyID := operation.ID
dateValues, _ := attrView.GetKeyValues(keyID)
if nil == dateValues || av.KeyTypeDate != dateValues.Key.Type {
return
}
if nil == dateValues.Key.Date {
dateValues.Key.Date = &av.Date{}
}
dateValues.Key.Date.FillSpecificTime = operation.Data.(bool)
for _, v := range dateValues.Values {
if !v.IsEmpty() {
continue
}
if nil == v.Date {
v.Date = &av.ValueDate{}
}
v.Date.IsNotTime = !dateValues.Key.Date.FillSpecificTime
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewCreatedIncludeTime(operation *Operation) (ret *TxErr) {
err := setAttrViewCreatedIncludeTime(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewCreatedIncludeTime(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
key, _ := attrView.GetKey(operation.ID)
if nil == key {
return
}
if nil == key.Created {
key.Created = &av.Created{}
}
key.Created.IncludeTime = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewUpdatedIncludeTime(operation *Operation) (ret *TxErr) {
err := setAttrViewUpdatedIncludeTime(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttrViewUpdatedIncludeTime(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
key, _ := attrView.GetKey(operation.ID)
if nil == key {
return
}
if nil == key.Updated {
key.Updated = &av.Updated{}
}
key.Updated.IncludeTime = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doHideAttrViewName(operation *Operation) (ret *TxErr) {
err := hideAttrViewName(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func hideAttrViewName(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", operation.AvID, err)
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if nil == view {
logging.LogErrorf("get view [%s] failed: %s", operation.BlockID, err)
return
}
view.HideAttrViewName = operation.Data.(bool)
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doUpdateAttrViewColRollup(operation *Operation) (ret *TxErr) {
err := updateAttributeViewColRollup(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColRollup(operation *Operation) (err error) {
// operation.AvID 汇总字段所在 av
// operation.ID 汇总字段 ID
// operation.ParentID 汇总字段基于的关联字段 ID
// operation.KeyID 目标字段 ID
// operation.Data 计算方式
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
rollUpKey, _ := attrView.GetKey(operation.ID)
if nil == rollUpKey {
return
}
var filters []*av.ViewFilter
oldDestAvID := ""
if nil != rollUpKey.Rollup {
filters = rollUpKey.Rollup.Filters
if oldRelationKey, _ := attrView.GetKey(rollUpKey.Rollup.RelationKeyID); nil != oldRelationKey &&
nil != oldRelationKey.Relation {
oldDestAvID = oldRelationKey.Relation.AvID
}
}
newDestAvID := ""
if newRelationKey, _ := attrView.GetKey(operation.ParentID); nil != newRelationKey && nil != newRelationKey.Relation {
newDestAvID = newRelationKey.Relation.AvID
}
if oldDestAvID != newDestAvID {
filters = nil
}
rollUpKey.Rollup = &av.Rollup{
RelationKeyID: operation.ParentID,
KeyID: operation.KeyID,
Filters: filters,
}
if nil == operation.Data {
return
}
data := operation.Data.(map[string]any)
if nil != data["calc"] {
calcData, jsonErr := gulu.JSON.MarshalJSON(data["calc"])
if nil != jsonErr {
err = jsonErr
return
}
if jsonErr = gulu.JSON.UnmarshalJSON(calcData, &rollUpKey.Rollup.Calc); nil != jsonErr {
err = jsonErr
return
}
}
// 如果存在该汇总字段的过滤条件,则移除该过滤条件 https://github.com/siyuan-note/siyuan/issues/15660
for _, view := range attrView.Views {
view.Filters = av.RemoveFiltersByColumn(view.Filters, rollUpKey.ID)
if 0 == len(view.Filters) {
// 保持 spec 5 根组不变量:根组被裁空后补一个空 AND 根组
view.Filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd}}
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doUpdateAttrViewColRelation(operation *Operation) (ret *TxErr) {
if err := tx.prepareRelationSourceJournal(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
err := updateAttributeViewColRelation(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColRelation(operation *Operation) (err error) {
// operation.AvID 源 avID
// operation.ID 目标 avID
// operation.KeyID 源 av 关联字段 ID
// operation.IsTwoWay 是否双向关联
// operation.BackRelationKeyID 双向关联的目标关联字段 ID
// operation.Name 双向关联的目标关联字段名称
// operation.Format 源 av 关联字段名称
srcAv, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
destAv, err := av.ParseAttributeView(operation.ID)
if err != nil {
return
}
isSameAv := srcAv.ID == destAv.ID
if isSameAv {
destAv = srcAv
}
oldDestAvID := ""
for _, keyValues := range srcAv.KeyValues {
if keyValues.Key.ID != operation.KeyID {
continue
}
srcRel := keyValues.Key.Relation
// 已经设置过双向关联的话需要先断开双向关联
if nil != srcRel {
oldDestAvID = srcRel.AvID
if srcRel.IsTwoWay {
oldDestAv, _ := av.ParseAttributeView(srcRel.AvID)
if nil != oldDestAv {
isOldSameAv := oldDestAv.ID == destAv.ID
if isOldSameAv {
oldDestAv = destAv
}
oldDestKey, _ := oldDestAv.GetKey(srcRel.BackKeyID)
if nil != oldDestKey && nil != oldDestKey.Relation && oldDestKey.Relation.AvID == srcAv.ID && oldDestKey.Relation.IsTwoWay {
oldDestKey.Relation.IsTwoWay = false
oldDestKey.Relation.BackKeyID = ""
}
if !isOldSameAv {
err = av.SaveAttributeView(oldDestAv)
if err != nil {
return
}
}
}
}
}
var candidateFilters []*av.ViewFilter
if nil != srcRel && srcRel.AvID == operation.ID {
candidateFilters = srcRel.CandidateFilters
}
srcRel = &av.Relation{
AvID: operation.ID,
IsTwoWay: operation.IsTwoWay,
CandidateFilters: candidateFilters,
}
if operation.IsTwoWay {
srcRel.BackKeyID = operation.BackRelationKeyID
} else {
srcRel.BackKeyID = ""
}
keyValues.Key.Relation = srcRel
keyValues.Key.Name = operation.Format
break
}
if oldDestAvID != operation.ID {
srcAv.RemoveNewItemTemplateFieldValue(operation.KeyID)
srcAv.RemoveExactRelationFilters(operation.KeyID)
for _, keyValues := range srcAv.KeyValues {
if nil != keyValues && nil != keyValues.Key && av.KeyTypeRollup == keyValues.Key.Type &&
nil != keyValues.Key.Rollup && keyValues.Key.Rollup.RelationKeyID == operation.KeyID {
keyValues.Key.Rollup.Filters = nil
}
}
}
destAdded := false
backRelKey, _ := destAv.GetKey(operation.BackRelationKeyID)
if nil != backRelKey {
backRelKey.Relation = &av.Relation{
AvID: operation.AvID,
IsTwoWay: operation.IsTwoWay,
BackKeyID: operation.KeyID,
}
destAdded = true
if operation.IsTwoWay {
name := strings.TrimSpace(operation.Name)
if "" == name {
name = srcAv.Name + " " + operation.Format
}
backRelKey.Name = strings.TrimSpace(name)
} else {
backRelKey.Relation.BackKeyID = ""
}
}
if !destAdded && operation.IsTwoWay {
// 新建双向关联目标字段
name := strings.TrimSpace(operation.Name)
if "" == name {
name = srcAv.Name + " " + operation.Format
name = strings.TrimSpace(name)
}
destKeyValues := &av.KeyValues{
Key: &av.Key{
ID: operation.BackRelationKeyID,
Name: name,
Type: av.KeyTypeRelation,
Relation: &av.Relation{AvID: operation.AvID, IsTwoWay: operation.IsTwoWay, BackKeyID: operation.KeyID},
},
}
addAttributeViewKey(destAv, nil, destKeyValues.Key, "")
destKeyValues, _ = destAv.GetKeyValues(operation.BackRelationKeyID)
now := time.Now().UnixMilli()
// 和现有值进行关联
for _, keyValues := range srcAv.KeyValues {
if keyValues.Key.ID != operation.KeyID {
continue
}
for _, srcVal := range keyValues.Values {
for _, blockID := range srcVal.Relation.BlockIDs {
destVal := destAv.GetValue(destKeyValues.Key.ID, blockID)
if nil == destVal {
destVal = &av.Value{ID: ast.NewNodeID(), KeyID: destKeyValues.Key.ID, BlockID: blockID, Type: keyValues.Key.Type, Relation: &av.ValueRelation{}, CreatedAt: now, UpdatedAt: now + 1000}
} else {
destVal.Type = keyValues.Key.Type
if nil == destVal.Relation {
destVal.Relation = &av.ValueRelation{}
}
destVal.UpdatedAt = now
destVal.IsRenderAutoFill = false
}
destVal.Relation.BlockIDs = append(destVal.Relation.BlockIDs, srcVal.BlockID)
destVal.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(destVal.Relation.BlockIDs)
destKeyValues.Values = append(destKeyValues.Values, destVal)
}
}
}
}
regenAttrViewGroups(srcAv)
err = av.SaveAttributeView(srcAv)
if err != nil {
return
}
if !isSameAv {
regenAttrViewGroups(destAv)
err = av.SaveAttributeView(destAv)
if err != nil {
return
}
ReloadAttrView(destAv.ID)
}
if oldDestAvID != "" && oldDestAvID != destAv.ID {
stillRelated := false
for _, kv := range srcAv.KeyValues {
if kv.Key.Type == av.KeyTypeRelation && kv.Key.Relation != nil && kv.Key.Relation.AvID == oldDestAvID {
stillRelated = true
break
}
}
if !stillRelated {
if err = av.RemoveAvRelWithErr(srcAv.ID, oldDestAvID); err != nil {
return
}
}
}
if err = av.UpsertAvBackRelWithErr(srcAv.ID, destAv.ID); err != nil {
return
}
if operation.IsTwoWay && !isSameAv {
if err = av.UpsertAvBackRelWithErr(destAv.ID, srcAv.ID); err != nil {
return
}
}
if "" != oldDestAvID && oldDestAvID != operation.ID && oldDestAvID != srcAv.ID {
ReloadAttrView(oldDestAvID)
}
return
}
func (tx *Transaction) doSortAttrViewView(operation *Operation) (ret *TxErr) {
avID := operation.AvID
attrView, err := avParseView(avID, operation.BlockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", operation.AvID, err)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
view := attrView.GetView(operation.ID)
if nil == view {
logging.LogErrorf("get view failed: %s", operation.BlockID)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: av.ErrViewNotFound.Error()}
}
viewID := view.ID
previousViewID := operation.PreviousID
if "" != previousViewID && nil == attrView.GetView(previousViewID) {
return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: av.ErrViewNotFound.Error()}
}
if viewID == previousViewID {
return
}
var index, previousIndex int
for i, v := range attrView.Views {
if v.ID == viewID {
view = v
index = i
break
}
}
attrView.Views = append(attrView.Views[:index], attrView.Views[index+1:]...)
for i, v := range attrView.Views {
if v.ID == previousViewID {
previousIndex = i + 1
break
}
}
attrView.Views = slices.Insert(attrView.Views, previousIndex, view)
if err = avSaveView(attrView, operation.BlockID); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrCodeWriteTree, msg: err.Error(), id: avID}
}
return
}
func (tx *Transaction) doRemoveAttrViewView(operation *Operation) (ret *TxErr) {
var err error
avID := operation.AvID
attrView, err := avParseView(avID, operation.BlockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrCodeBlockNotFound, id: avID}
}
if 1 >= len(attrView.Views) {
logging.LogWarnf("can't remove last view [%s] of attribute view [%s]", operation.AvID, avID)
return
}
view, err := getAttrViewViewToRemove(attrView, operation)
if nil == view {
logging.LogWarnf("get view [%s] to remove failed: %s", operation.ID, err)
if nil == err {
err = av.ErrViewNotFound
}
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
viewID := view.ID
var index int
for i, view := range attrView.Views {
if viewID == view.ID {
attrView.Views = append(attrView.Views[:i], attrView.Views[i+1:]...)
index = i - 1
break
}
}
if 0 > index {
index = 0
}
view = attrView.Views[index]
if err = avSaveView(attrView, operation.BlockID); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrCodeWriteTree, msg: err.Error(), id: avID}
}
trees, nodes := getMirrorBlocksNodes(avID)
for _, node := range nodes {
attrs := parse.IAL2Map(node.KramdownIAL)
changed := false
visibleViewIDsValue := attrs[av.NodeAttrVisibleViewIDs]
visibleViewIDs := attrView.GetVisibleViewIDs(visibleViewIDsValue)
if "" != visibleViewIDsValue {
normalized := strings.Join(visibleViewIDs, ",")
if normalized != visibleViewIDsValue {
attrs[av.NodeAttrVisibleViewIDs] = normalized
changed = true
}
}
blockViewID := attrs[av.NodeAttrView]
if blockViewID == viewID {
attrs[av.NodeAttrView] = visibleViewIDs[0]
fallbackView := attrView.GetView(visibleViewIDs[0])
node.AttributeViewType = string(fallbackView.LayoutType)
changed = true
}
if !changed {
continue
}
// 镜像块节点未关联 tree,通过 blocktree 解析 boxID 以走加密笔记本守卫与 box-aware 缓存键
boxID := ""
if bt := treenode.GetBlockTree(node.ID); nil != bt {
boxID = bt.BoxID
}
oldAttrs, e := setNodeAttrs0(node, attrs, boxID)
if nil != e {
logging.LogErrorf("set node attrs failed: %s", e)
continue
}
cache.PutBlockIALInBox(node.ID, boxID, parse.IAL2Map(node.KramdownIAL))
pushBlockAttrs(oldAttrs, node)
}
for _, tree := range trees {
if err = indexWriteTreeUpsertQueue(tree); err != nil {
return
}
}
operation.RetData = view.LayoutType
return
}
func getAttrViewViewToRemove(attrView *av.AttributeView, operation *Operation) (ret *av.View, err error) {
if "" != operation.ID {
ret = attrView.GetView(operation.ID)
if nil == ret {
err = av.ErrViewNotFound
}
return
}
return getAttrViewViewByBlockID(attrView, operation.BlockID)
}
func getMirrorBlocksNodes(avID string) (trees []*parse.Tree, nodes []*ast.Node) {
mirrorBlockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
mirrorBlockTrees := filesys.LoadTrees(mirrorBlockIDs)
for id, tree := range mirrorBlockTrees {
node := treenode.GetNodeInTree(tree, id)
if nil == node {
logging.LogErrorf("get node in tree by block ID [%s] failed", id)
continue
}
nodes = append(nodes, node)
}
for _, tree := range mirrorBlockTrees {
trees = append(trees, tree)
}
return
}
func freezeOtherAttrViewBlockVisibleViews(attrView *av.AttributeView, currentBlockID string, currentTree *parse.Tree) (err error) {
var oldViewIDs []string
for _, view := range attrView.Views {
oldViewIDs = append(oldViewIDs, view.ID)
}
if 1 > len(oldViewIDs) {
return
}
value := strings.Join(oldViewIDs, ",")
var otherBlockIDs []string
for _, blockID := range treenode.GetMirrorAttrViewBlockIDs(attrView.ID) {
if blockID != currentBlockID {
otherBlockIDs = append(otherBlockIDs, blockID)
}
}
mirrorBlockTrees := filesys.LoadTrees(otherBlockIDs)
changedTrees := map[string]*parse.Tree{}
for blockID, tree := range mirrorBlockTrees {
if tree.Root.ID == currentTree.Root.ID {
tree = currentTree
}
node := treenode.GetNodeInTree(tree, blockID)
if nil == node {
logging.LogErrorf("get node in tree by block ID [%s] failed", blockID)
continue
}
if "" != node.IALAttr(av.NodeAttrVisibleViewIDs) {
continue
}
boxID := tree.Box
oldAttrs, setErr := setNodeAttrs0(node, map[string]string{av.NodeAttrVisibleViewIDs: value}, boxID)
if nil != setErr {
return setErr
}
cache.PutBlockIALInBox(node.ID, boxID, parse.IAL2Map(node.KramdownIAL))
pushBlockAttrs(oldAttrs, node)
if tree.Root.ID != currentTree.Root.ID {
changedTrees[tree.Root.ID] = tree
}
}
for _, tree := range changedTrees {
if err = indexWriteTreeUpsertQueue(tree); nil != err {
return
}
}
return
}
func (tx *Transaction) doDuplicateAttrViewRow(operation *Operation) (ret *TxErr) {
srcRowID := ""
if 0 < len(operation.SrcIDs) {
srcRowID = operation.SrcIDs[0]
}
if "" == srcRowID {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "source row id is empty"}
}
if err := DuplicateAttributeViewRow(tx, operation.AvID, operation.PreviousID, srcRowID, operation.ID); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doDuplicateAttrViewView(operation *Operation) (ret *TxErr) {
var err error
avID := operation.AvID
attrView, err := avParseView(avID, operation.BlockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrHandleAttributeView, id: avID}
}
masterView := attrView.GetView(operation.PreviousID)
if nil == masterView {
logging.LogErrorf("get master view failed: %s", avID)
return &TxErr{code: TxErrHandleAttributeView, id: avID}
}
node, tree, _ := getNodeByBlockID(nil, operation.BlockID)
if nil == node {
logging.LogErrorf("get node by block ID [%s] failed", operation.BlockID)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID}
}
visibleViewIDs := attrView.GetVisibleViewIDs(node.IALAttr(av.NodeAttrVisibleViewIDs))
visibleViewIDs = append(visibleViewIDs, operation.ID)
if err = freezeOtherAttrViewBlockVisibleViews(attrView, operation.BlockID, tree); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
attrs := parse.IAL2Map(node.KramdownIAL)
attrs[av.NodeAttrView] = operation.ID
attrs[av.NodeAttrVisibleViewIDs] = strings.Join(visibleViewIDs, ",")
node.AttributeViewType = string(masterView.LayoutType)
err = setNodeAttrs(node, tree, attrs)
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", operation.BlockID, err)
return
}
var view *av.View
switch masterView.LayoutType {
case av.LayoutTypeCalendar:
view = av.NewCalendarView()
case av.LayoutTypeList:
view = av.NewListView()
case av.LayoutTypeTable:
view = av.NewTableView()
case av.LayoutTypeGallery:
view = av.NewGalleryView()
case av.LayoutTypeKanban:
view = av.NewKanbanView()
}
view.ID = operation.ID
attrView.Views = append(attrView.Views, view)
view.Icon = masterView.Icon
view.Name = util.GetDuplicateName(masterView.Name)
if name := strings.TrimSpace(operation.Name); "" != name {
view.Name = name
}
view.HideAttrViewName = masterView.HideAttrViewName
view.Desc = masterView.Desc
view.LayoutType = masterView.LayoutType
view.PageSize = masterView.PageSize
view.Filters = av.CloneFilters(masterView.Filters)
view.ConditionalColors = av.CloneConditionalColors(masterView.ConditionalColors)
for _, s := range masterView.Sorts {
view.Sorts = append(view.Sorts, &av.ViewSort{
Column: s.Column,
ValueSource: s.ValueSource,
Order: s.Order,
DateEndpoint: s.DateEndpoint,
})
}
if err = cloneAttributeViewLayouts(view, masterView); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: err.Error()}
}
view.ItemIDs = masterView.ItemIDs
if nil != masterView.Group {
view.Group = &av.ViewGroup{}
if copyErr := copier.Copy(view.Group, masterView.Group); nil != copyErr {
logging.LogErrorf("copy group failed: %s", copyErr)
return &TxErr{code: TxErrHandleAttributeView, id: avID, msg: copyErr.Error()}
}
view.GroupItemIDs = masterView.GroupItemIDs
regenAttrViewGroups(attrView)
}
if err = avSaveView(attrView, operation.BlockID); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrHandleAttributeView, msg: err.Error(), id: avID}
}
return
}
func (tx *Transaction) doAddAttrViewView(operation *Operation) (ret *TxErr) {
err := addAttrViewViewNamed(operation.AvID, operation.ID, operation.BlockID, operation.Name, operation.Layout)
if nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func addAttrViewView(avID, viewID, blockID string, layout av.LayoutType) (err error) {
return addAttrViewViewNamed(avID, viewID, blockID, "", layout)
}
func addAttrViewViewNamed(avID, viewID, blockID, name string, layout av.LayoutType) (err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
if 1 > len(attrView.Views) {
logging.LogErrorf("no view in attribute view [%s]", avID)
return
}
firstView := attrView.Views[0]
if nil == firstView {
logging.LogErrorf("get first view failed: %s", avID)
return
}
if "" == layout {
layout = av.LayoutTypeTable
}
fieldIDs := attributeViewFieldIDs(firstView)
// 表格类布局之间复制字段时保留列宽和对齐,其他来源只带字段顺序。
var tableColumns []*av.ViewTableColumn
switch firstView.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
if table := firstView.GetTableLayout(); nil != table {
tableColumns = table.Columns
}
}
var view *av.View
switch layout {
case av.LayoutTypeCalendar:
view = av.NewCalendarView()
view.Calendar = newAttributeViewCalendarLayout(attrView, fieldIDs)
case av.LayoutTypeList:
view = av.NewListView()
view.List = newAttributeViewListLayout(attrView, fieldIDs)
case av.LayoutTypeTable:
view = av.NewTableView()
for i, id := range fieldIDs {
column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: id}}
if i < len(tableColumns) && nil != tableColumns[i] {
column.Width, column.Align = tableColumns[i].Width, tableColumns[i].Align
}
view.Table.Columns = append(view.Table.Columns, column)
}
case av.LayoutTypeGallery:
view = av.NewGalleryView()
for _, id := range fieldIDs {
view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: id}})
}
case av.LayoutTypeKanban:
view = av.NewKanbanView()
for _, id := range fieldIDs {
view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: id}})
}
default:
err = av.ErrWrongLayoutType
logging.LogErrorf("wrong layout type [%s] for attribute view [%s]", layout, avID)
return
}
node, tree, _ := getNodeByBlockID(nil, blockID)
if nil == node {
logging.LogErrorf("get node by block ID [%s] failed", blockID)
return
}
visibleViewIDs := attrView.GetVisibleViewIDs(node.IALAttr(av.NodeAttrVisibleViewIDs))
visibleViewIDs = append(visibleViewIDs, viewID)
if err = freezeOtherAttrViewBlockVisibleViews(attrView, blockID, tree); nil != err {
return
}
view.ItemIDs = firstView.ItemIDs
view.ID = viewID
if name = strings.TrimSpace(name); "" != name {
view.Name = name
}
attrView.Views = append(attrView.Views, view)
if av.LayoutTypeKanban == layout {
preferredGroupKey := getKanbanPreferredGroupKey(attrView)
group := &av.ViewGroup{Field: preferredGroupKey.ID}
setAttributeViewGroup(attrView, view, group)
}
node.AttributeViewType = string(view.LayoutType)
attrs := parse.IAL2Map(node.KramdownIAL)
attrs[av.NodeAttrView] = viewID
attrs[av.NodeAttrVisibleViewIDs] = strings.Join(visibleViewIDs, ",")
err = setNodeAttrs(node, tree, attrs)
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", blockID, err)
return
}
if err = avSaveView(attrView, blockID); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return
}
return
}
func getKanbanPreferredGroupKey(attrView *av.AttributeView) (ret *av.Key) {
for _, kv := range attrView.KeyValues {
if av.KeyTypeSelect == kv.Key.Type {
ret = kv.Key
break
}
}
if nil == ret {
name := av.GetAttributeViewI18n("select")
ret = av.NewKey(ast.NewNodeID(), name, "", av.KeyTypeSelect)
addAttributeViewKey(attrView, nil, ret, "")
}
return
}
// setAttrViewViewField 读取视图并应用 apply 修改后保存,供视图名称、图标、描述的写入共用。
// 视图不存在时按视图 ID 报错,不再沿用上层解析留下的 err,避免打印 "failed: <nil>"。
func (tx *Transaction) setAttrViewViewField(operation *Operation, apply func(view *av.View)) (ret *TxErr) {
avID := operation.AvID
attrView, err := avParseView(avID, operation.BlockID)
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrHandleAttributeView, id: avID}
}
viewID := operation.ID
view := attrView.GetView(viewID)
if nil == view {
logging.LogErrorf("attribute view [%s] has no view [%s]", avID, viewID)
return &TxErr{code: TxErrHandleAttributeView, id: viewID}
}
apply(view)
if err = avSaveView(attrView, operation.BlockID); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", avID, err)
return &TxErr{code: TxErrHandleAttributeView, msg: err.Error(), id: avID}
}
return
}
func (tx *Transaction) doSetAttrViewViewName(operation *Operation) (ret *TxErr) {
return tx.setAttrViewViewField(operation, func(view *av.View) {
view.Name = strings.TrimSpace(operation.Data.(string))
})
}
func (tx *Transaction) doSetAttrViewViewIcon(operation *Operation) (ret *TxErr) {
return tx.setAttrViewViewField(operation, func(view *av.View) {
view.Icon = filterAttrViewIconValue(operation.Data.(string))
})
}
// filterAttrViewIconValue 过滤属性视图图标值,非法值置空,防止存储可执行标记
// https://github.com/siyuan-note/siyuan/security/advisories/GHSA-vx5w-qrvp-mmcq
func filterAttrViewIconValue(icon string) string {
if filtered, valid := util.FilterIconValue(icon); valid {
return filtered
}
return ""
}
func (tx *Transaction) doSetAttrViewViewDesc(operation *Operation) (ret *TxErr) {
return tx.setAttrViewViewField(operation, func(view *av.View) {
view.Desc = strings.TrimSpace(operation.Data.(string))
})
}
func (tx *Transaction) doSetAttrViewName(operation *Operation) (ret *TxErr) {
err := tx.setAttributeViewName(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewNewItemTemplates(operation *Operation) (ret *TxErr) {
attrView, err := av.ParseAttributeView(operation.AvID)
if nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
data, err := gulu.JSON.MarshalJSON(operation.Data)
if nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
config := &av.NewItemTemplatesConfig{}
if err = gulu.JSON.UnmarshalJSON(data, config); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = attrView.SetNewItemTemplates(config); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = av.SaveAttributeView(attrView); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
ReloadAttrView(operation.AvID)
return
}
const attrAvNameTpl = `<span data-av-id="${avID}" data-popover-url="/api/av/getMirrorDatabaseBlocks" class="popover__block">${avName}</span>`
func (tx *Transaction) setAttributeViewName(operation *Operation) (err error) {
avID := operation.ID
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
attrView.Name = strings.TrimSpace(operation.Data.(string))
attrView.Name = strings.ReplaceAll(attrView.Name, "\n", " ")
if 512 < utf8.RuneCountInString(attrView.Name) {
attrView.Name = gulu.Str.SubStr(attrView.Name, 512)
}
err = av.SaveAttributeView(attrView)
_, nodes := tx.getAttrViewBoundNodes(attrView)
for _, node := range nodes {
avNames := getAvNames(node.IALAttr(av.NodeAttrNameAvs))
oldAttrs := parse.IAL2Map(node.KramdownIAL)
node.SetIALAttr(av.NodeAttrViewNames, avNames)
pushBlockAttrs(oldAttrs, node)
}
return
}
func getAvNames(avIDs string) (ret string) {
if "" == avIDs {
return
}
avNames := bytes.Buffer{}
nodeAvIDs := strings.SplitSeq(avIDs, ",")
for nodeAvID := range nodeAvIDs {
nodeAvName, getErr := av.GetAttributeViewName(nodeAvID)
if nil != getErr {
continue
}
if "" == nodeAvName {
nodeAvName = Conf.language(105)
}
tpl := strings.ReplaceAll(attrAvNameTpl, "${avID}", nodeAvID)
tpl = strings.ReplaceAll(tpl, "${avName}", util.EscapeHTML(nodeAvName))
avNames.WriteString(tpl)
avNames.WriteString(" ")
}
if 0 < avNames.Len() {
avNames.Truncate(avNames.Len() - 6)
ret = avNames.String()
}
return
}
func (tx *Transaction) getAttrViewBoundNodes(attrView *av.AttributeView) (trees map[string]*parse.Tree, nodes []*ast.Node) {
blockKeyValues := attrView.GetBlockKeyValues()
if nil == blockKeyValues || nil == blockKeyValues.Values {
return
}
trees = map[string]*parse.Tree{}
for _, blockKeyValue := range blockKeyValues.Values {
if blockKeyValue.IsDetached || nil == blockKeyValue.Block {
continue
}
blockID := blockKeyValue.Block.ID
if "" == blockID {
continue
}
var tree *parse.Tree
tree = trees[blockID]
if nil == tree {
if nil == tx {
tree, _ = LoadTreeByBlockID(blockID)
} else {
tree, _ = tx.loadTree(blockID)
}
}
if nil == tree {
continue
}
trees[blockID] = tree
node := treenode.GetNodeInTree(tree, blockID)
if nil == node {
continue
}
nodes = append(nodes, node)
}
return
}
func (tx *Transaction) doSetAttrViewFilters(operation *Operation) (ret *TxErr) {
err := SetAttrViewFilters(operation.AvID, operation.BlockID, operation.Data.([]any))
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewColRelationFilters(operation *Operation) (ret *TxErr) {
err := setAttrViewColFilters(operation.AvID, operation.BlockID, operation.KeyID, operation.Data.([]any), true)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewColRollupFilters(operation *Operation) (ret *TxErr) {
err := setAttrViewColFilters(operation.AvID, operation.BlockID, operation.KeyID, operation.Data.([]any), false)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
// avParseView 根据 blockID 推导 AV 的精确加密边界。
func avParseView(avID, blockID string) (*av.AttributeView, error) {
boxID, exact, err := resolveAttributeViewCarrierBoxID(blockID)
if nil != err {
return nil, err
}
if exact {
av.SetAVBoxID(avID, boxID)
return av.ParseAttributeViewInBox(avID, boxID)
}
return av.ParseAttributeView(avID)
}
// avSaveView 根据 blockID 推导 box 上下文,使用 box-aware 或全局 AV 保存。
func avSaveView(attrView *av.AttributeView, blockID string) error {
boxID, exact, err := resolveAttributeViewCarrierBoxID(blockID)
if nil != err {
return err
}
if exact {
av.SetAVBoxID(attrView.ID, boxID)
}
return av.SaveAttributeView(attrView)
}
// GetAttributeViewContextFilter 读取物理数据库块独有的上下文筛选配置。
func GetAttributeViewContextFilter(attrView *av.AttributeView,
blockID string) (ret *av.AttributeViewContextFilter, err error) {
if nil == attrView || "" == blockID {
return
}
node, _, err := getNodeByBlockID(nil, blockID)
if nil != err {
return nil, err
}
// 普通内容块的数据库属性面板也会以内容块 ID 渲染属性视图,此时不存在块级上下文筛选。
if nil == node || ast.NodeAttributeView != node.Type {
return nil, nil
}
if node.AttributeViewID != attrView.ID {
return nil, fmt.Errorf("block [%s] is not an instance of attribute view [%s]", blockID, attrView.ID)
}
ret, err = av.ParseAttributeViewContextFilter(node.IALAttr(av.NodeAttrContextFilter))
if nil != err {
return nil, fmt.Errorf("parse attribute view context filter: %w", err)
}
return
}
func getAttributeViewInstanceNode(attrView *av.AttributeView,
blockID string) (node *ast.Node, tree *parse.Tree, err error) {
if nil == attrView || "" == blockID {
return nil, nil, av.ErrAttributeViewNotFound
}
node, tree, err = getNodeByBlockID(nil, blockID)
if nil != err {
return
}
if nil == node || nil == tree || ast.NodeAttributeView != node.Type || node.AttributeViewID != attrView.ID {
return nil, nil, fmt.Errorf("block [%s] is not an instance of attribute view [%s]", blockID, attrView.ID)
}
return
}
// SetAttributeViewContextFilter 设置物理数据库块独有的上下文筛选配置,keyID 为空时清除。
func SetAttributeViewContextFilter(blockID, avID, keyID string) (ret *av.AttributeViewContextFilter, err error) {
return setAttributeViewContextFilter(nil, blockID, avID, keyID)
}
func setAttributeViewContextFilter(tx *Transaction, blockID, avID,
keyID string) (ret *av.AttributeViewContextFilter, err error) {
attrView, err := avParseView(avID, blockID)
if nil != err {
return nil, err
}
node, tree, err := getAttributeViewInstanceNode(attrView, blockID)
if nil != err {
return nil, err
}
var value string
keyID = strings.TrimSpace(keyID)
if "" != keyID {
ret = &av.AttributeViewContextFilter{Spec: av.AttributeViewContextFilterSpec, KeyID: keyID}
// undo/redo 重放需要能恢复字段删除或改型后留下的旧配置;普通事务和公开 API 仍严格校验。
if nil == tx || !tx.isReplay {
if _, err = resolveAttributeViewContextFilterTarget(attrView, ret, tree.Box); nil != err {
return nil, fmt.Errorf("validate attribute view context filter target: %w", err)
}
}
if value, err = ret.Marshal(); nil != err {
return nil, err
}
}
if value == node.IALAttr(av.NodeAttrContextFilter) {
return
}
attrs := map[string]string{av.NodeAttrContextFilter: value}
if nil != tx {
err = setNodeAttrsWithTx(tx, node, tree, attrs)
} else {
err = setNodeAttrs(node, tree, attrs)
}
return
}
func (tx *Transaction) doSetAttrViewContextFilter(operation *Operation) (ret *TxErr) {
_, err := setAttributeViewContextFilter(tx, operation.BlockID, operation.AvID, operation.KeyID)
if nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
// resolveAttributeViewFilterContext 将数据库块所在根文档映射为关联目标数据库的条目 ID。
func resolveAttributeViewFilterContext(attrView *av.AttributeView, _ *av.View,
blockID string) (*av.FilterContext, error) {
if nil == attrView || "" == blockID {
return nil, nil
}
contextFilter, err := GetAttributeViewContextFilter(attrView, blockID)
if nil != err {
return nil, err
}
if nil == contextFilter {
return nil, nil
}
context := &av.FilterContext{KeyID: contextFilter.KeyID}
// 字段删除、改型或关联目标失效时保留块级配置,并以空上下文安全渲染。
// 这样撤销字段变更后配置可自动恢复,用户也可在界面中显式禁用。
_, tree, err := getAttributeViewInstanceNode(attrView, blockID)
if nil != err {
return nil, err
}
targetAttrView, targetErr := resolveAttributeViewContextFilterTarget(attrView, contextFilter, tree.Box)
if nil != targetErr {
return context, nil
}
blockValue := targetAttrView.GetBlockValueByBoundID(tree.Root.ID)
if nil != blockValue && "" != blockValue.BlockID {
context.CurrentDocumentItemIDs = []string{blockValue.BlockID}
}
return context, nil
}
func resolveAttributeViewContextFilterTarget(attrView *av.AttributeView, contextFilter *av.AttributeViewContextFilter,
carrierBoxID string) (ret *av.AttributeView, err error) {
if nil == contextFilter || av.AttributeViewContextFilterSpec != contextFilter.Spec {
return nil, av.ErrInvalidAttributeViewContextFilter
}
load := attributeViewContextFilterLoader(attrView, carrierBoxID)
key, err := attrView.ResolveRelationKey(contextFilter.KeyID, load)
if nil != err {
return nil, err
}
return load(key.Relation.AvID)
}
// GetAttributeViewContextFilterFields 在承载数据库块的笔记本范围内解析上下文筛选候选。
func GetAttributeViewContextFilterFields(attrView *av.AttributeView, blockID string) []*av.AttributeViewContextFilterField {
boxID, _, err := resolveAttributeViewCarrierBoxID(blockID)
if nil != err {
return []*av.AttributeViewContextFilterField{}
}
return attrView.ContextFilterFields(attributeViewContextFilterLoader(attrView, boxID))
}
func attributeViewContextFilterLoader(attrView *av.AttributeView,
carrierBoxID string) func(string) (*av.AttributeView, error) {
return func(avID string) (*av.AttributeView, error) {
if nil != attrView && avID == attrView.ID {
return attrView, nil
}
targetBoxID := ""
if IsEncryptedBox(carrierBoxID) {
targetBoxID = carrierBoxID
}
av.SetAVBoxID(avID, targetBoxID)
ret, err := av.ParseAttributeViewInBox(avID, targetBoxID)
if nil != err {
return nil, err
}
if nil == ret {
return nil, av.ErrAttributeViewNotFound
}
return ret, nil
}
}
func getAttributeViewCarrierBlockTree(blockID string) *treenode.BlockTree {
if "" == blockID {
return nil
}
blockTree := treenode.GetBlockTree(blockID)
if nil != blockTree {
return blockTree
}
for _, encBoxID := range treenode.GetOpenedEncryptedBoxIDs() {
if blockTree = treenode.GetBlockTreeInBox(blockID, encBoxID); nil != blockTree {
return blockTree
}
}
return nil
}
func resolveAttributeViewCarrierBoxID(blockID string) (boxID string, exact bool, err error) {
if "" == blockID {
return "", false, nil
}
blockTree := getAttributeViewCarrierBlockTree(blockID)
if nil == blockTree {
return "", true, fmt.Errorf("resolve attribute view carrier: block [%s] not found", blockID)
}
if IsEncryptedBox(blockTree.BoxID) {
return blockTree.BoxID, true, nil
}
return "", true, nil
}
// SetAttrViewFilters 用新的过滤规则数组整体替换指定视图的过滤规则,并持久化。
// data 为 JSON 反序列化前的 []any(通常是前端传来的过滤节点树)。
func SetAttrViewFilters(avID, blockID string, data []any) (err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
jsonData, err := gulu.JSON.MarshalJSON(data)
if err != nil {
return
}
var newFilters []*av.ViewFilter
if err = gulu.JSON.UnmarshalJSON(jsonData, &newFilters); err != nil {
return
}
view.Filters = newFilters
// 归一化为单一根组:spec 5 起顶层应为一个根组。
// 兜底旧前端/异常数据发来的扁平叶子数组,在内存里包成 AND 根组后再持久化。
if 1 != len(view.Filters) || nil == view.Filters[0] || !view.Filters[0].IsGroup() {
view.Filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd, Filters: view.Filters}}
}
// 限制筛选嵌套深度,防止异常数据创建过深的嵌套分组。
if err = av.ValidateFilterDepth(view.Filters); nil != err {
return
}
err = avSaveView(attrView, blockID)
return
}
func setAttrViewColFilters(avID, blockID, keyID string, data []any, relation bool) (err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
key, _ := attrView.GetKey(keyID)
if nil == key {
return av.ErrKeyNotFound
}
destAvID := ""
if relation {
if av.KeyTypeRelation != key.Type || nil == key.Relation {
return av.ErrKeyNotFound
}
destAvID = key.Relation.AvID
} else {
if av.KeyTypeRollup != key.Type || nil == key.Rollup {
return av.ErrKeyNotFound
}
relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
if nil == relationKey || nil == relationKey.Relation {
return av.ErrKeyNotFound
}
destAvID = relationKey.Relation.AvID
}
destAttrView := attrView
if destAvID != avID {
destAttrView, err = av.ParseAttributeView(destAvID)
if err != nil {
return
}
}
jsonData, err := gulu.JSON.MarshalJSON(data)
if err != nil {
return
}
var filters []*av.ViewFilter
if err = gulu.JSON.UnmarshalJSON(jsonData, &filters); err != nil {
return
}
if 0 < len(filters) && (1 != len(filters) || nil == filters[0] || !filters[0].IsGroup()) {
filters = []*av.ViewFilter{{Combination: av.FilterCombinationAnd, Filters: filters}}
}
if err = av.ValidateFilterDepth(filters); nil != err {
return
}
validColumns := map[string]bool{}
for _, keyValues := range destAttrView.KeyValues {
if nil != keyValues && nil != keyValues.Key {
validColumns[keyValues.Key.ID] = true
}
}
filters, _ = av.PruneInvalidColumnFilters(filters, validColumns)
if !hasAttrViewFilterConditions(filters) {
filters = nil
}
if relation {
key.Relation.CandidateFilters = filters
} else {
key.Rollup.Filters = filters
}
err = avSaveView(attrView, blockID)
return
}
func hasAttrViewFilterConditions(filters []*av.ViewFilter) bool {
for _, filter := range filters {
if nil == filter {
continue
}
if filter.IsGroup() {
if hasAttrViewFilterConditions(filter.Filters) {
return true
}
continue
}
return true
}
return false
}
func attrViewFiltersContainColumn(filters []*av.ViewFilter, column string) bool {
for _, filter := range filters {
if nil == filter {
continue
}
if filter.IsGroup() {
if attrViewFiltersContainColumn(filter.Filters, column) {
return true
}
continue
}
if filter.Column == column {
return true
}
}
return false
}
func attrViewFiltersContainOption(filters []*av.ViewFilter, column, optionContent string) bool {
for _, filter := range filters {
if nil == filter {
continue
}
if filter.IsGroup() {
if attrViewFiltersContainOption(filter.Filters, column, optionContent) {
return true
}
continue
}
if filter.Column != column || nil == filter.Value {
continue
}
for _, option := range filter.Value.MSelect {
if nil != option && option.Content == optionContent {
return true
}
}
}
return false
}
func removeAttrViewColumnFromFieldFilters(attrView *av.AttributeView, targetAvID, column string) (changed bool) {
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
key := keyValues.Key
if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
attrViewFiltersContainColumn(key.Relation.CandidateFilters, column) {
key.Relation.CandidateFilters = av.RemoveFiltersByColumn(key.Relation.CandidateFilters, column)
if !hasAttrViewFilterConditions(key.Relation.CandidateFilters) {
key.Relation.CandidateFilters = nil
}
changed = true
continue
}
if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
!attrViewFiltersContainColumn(key.Rollup.Filters, column) {
continue
}
relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
continue
}
key.Rollup.Filters = av.RemoveFiltersByColumn(key.Rollup.Filters, column)
if !hasAttrViewFilterConditions(key.Rollup.Filters) {
key.Rollup.Filters = nil
}
changed = true
}
return
}
func removeAttrViewOptionFromFieldFilters(attrView *av.AttributeView, targetAvID, column,
optionContent string) (changed bool) {
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
key := keyValues.Key
if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
attrViewFiltersContainOption(key.Relation.CandidateFilters, column, optionContent) {
key.Relation.CandidateFilters = av.RemoveSelectOptionFromFilters(
key.Relation.CandidateFilters, column, optionContent)
if !hasAttrViewFilterConditions(key.Relation.CandidateFilters) {
key.Relation.CandidateFilters = nil
}
changed = true
continue
}
if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
!attrViewFiltersContainOption(key.Rollup.Filters, column, optionContent) {
continue
}
relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
continue
}
key.Rollup.Filters = av.RemoveSelectOptionFromFilters(key.Rollup.Filters, column, optionContent)
if !hasAttrViewFilterConditions(key.Rollup.Filters) {
key.Rollup.Filters = nil
}
changed = true
}
return
}
func renameAttrViewOptionInFieldFilters(attrView *av.AttributeView, targetAvID, column,
oldContent, newContent, newColor string) (changed bool) {
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
key := keyValues.Key
if av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.AvID == targetAvID &&
attrViewFiltersContainOption(key.Relation.CandidateFilters, column, oldContent) {
av.RenameSelectOptionInFilters(key.Relation.CandidateFilters, column, oldContent, newContent, newColor)
changed = true
continue
}
if av.KeyTypeRollup != key.Type || nil == key.Rollup ||
!attrViewFiltersContainOption(key.Rollup.Filters, column, oldContent) {
continue
}
relationKey, _ := attrView.GetKey(key.Rollup.RelationKeyID)
if nil == relationKey || nil == relationKey.Relation || relationKey.Relation.AvID != targetAvID {
continue
}
av.RenameSelectOptionInFilters(key.Rollup.Filters, column, oldContent, newContent, newColor)
changed = true
}
return
}
func (tx *Transaction) doSetAttrViewSorts(operation *Operation) (ret *TxErr) {
err := SetAttrViewSorts(operation.AvID, operation.BlockID, operation.Data.([]any))
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
// SetAttrViewSorts 用新的排序规则数组整体替换指定视图的排序规则,并持久化。
// data 为 JSON 反序列化前的 []any。
func SetAttrViewSorts(avID, blockID string, data []any) (err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
jsonData, err := gulu.JSON.MarshalJSON(data)
if err != nil {
return
}
var newSorts []*av.ViewSort
if err = gulu.JSON.UnmarshalJSON(jsonData, &newSorts); err != nil {
return
}
view.Sorts = newSorts
err = avSaveView(attrView, blockID)
return
}
func (tx *Transaction) doSetAttrViewPageSize(operation *Operation) (ret *TxErr) {
err := setAttributeViewPageSize(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewPageSize(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
view.PageSize = int(operation.Data.(float64))
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColCalc(operation *Operation) (ret *TxErr) {
err := setAttributeViewColumnCalc(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColumnCalc(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
operationData := operation.Data
data, err := gulu.JSON.MarshalJSON(operationData)
if err != nil {
return
}
calc := &av.FieldCalc{}
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
if err = gulu.JSON.UnmarshalJSON(data, calc); err != nil {
return
}
for _, column := range view.GetTableLayout().Columns {
if column.ID == operation.ID {
column.Calc = calc
break
}
}
case av.LayoutTypeGallery, av.LayoutTypeKanban:
return
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doInsertAttrViewBlock(operation *Operation) (ret *TxErr) {
if operation.attributeViewFields != nil {
if err := tx.restoreDeletedAttributeViewBlocks(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
if nil != operation.attributeViewItems {
if err := tx.restoreAttributeViewItems(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
result, err := addAttributeViewBlocks(tx, operation.Srcs, operation.AvID, operation.BlockID, operation.ViewID,
operation.GroupID, operation.PreviousID, operation.IgnoreDefaultFill, operation.attributeViewAutomation, operation.attributeViewCollectionRuleID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
operation.RetData = result
return
}
func AddAttributeViewBlock(tx *Transaction, srcs []map[string]any, avID, dbBlockID, viewID, groupID, previousItemID string, ignoreDefaultFill bool) (err error) {
_, err = addAttributeViewBlocks(tx, srcs, avID, dbBlockID, viewID, groupID, previousItemID, ignoreDefaultFill, false)
return
}
type insertAttrViewBlockResult struct {
InsertedItemIDs []string `json:"insertedItemIDs"`
ExistingItemIDs []string `json:"existingItemIDs"`
}
func addAttributeViewBlocks(tx *Transaction, srcs []map[string]any, avID, dbBlockID, viewID, groupID, previousItemID string,
ignoreDefaultFill, databaseScope bool, collectionRuleIDs ...string) (result *insertAttrViewBlockResult, err error) {
result = &insertAttrViewBlockResult{}
if 0 == len(srcs) {
return
}
slices.Reverse(srcs) // https://github.com/siyuan-note/siyuan/issues/11286
attrView, err := avParseView(avID, dbBlockID)
if err != nil {
return
}
if err = tx.rememberAutomationView(attrView, dbBlockID); err != nil {
return
}
// 整批校验完成后再写入,避免后续条目越界时已修改前面的绑定。
boundTrees := map[string]*parse.Tree{}
detachedSources := make([]bool, len(srcs))
for index, src := range srcs {
if nil == src {
return result, fmt.Errorf("invalid attribute view source [%d]", index)
}
// 绑定条目的序列化数据可能省略值为 false 的字段,撤销重放时按绑定状态读取。
isDetached, ok := src["isDetached"].(bool)
if !ok && nil != src["isDetached"] {
return result, fmt.Errorf("invalid attribute view source [%d]: isDetached must be a boolean", index)
}
detachedSources[index] = isDetached
if isDetached {
continue
}
id, ok := src["id"].(string)
if !ok {
return result, fmt.Errorf("invalid attribute view source [%d]: id must be a string", index)
}
if !ast.IsNodeIDPattern(id) {
continue
}
var tree *parse.Tree
if tx != nil {
tree, err = tx.loadTree(id)
} else {
tree, err = LoadTreeByBlockID(id)
}
if err != nil {
return
}
if err = validateAttributeViewBinding(avID, tree); err != nil {
return
}
boundTrees[id] = tree
}
now := time.Now().UnixMilli()
for index, src := range srcs {
boundBlockID := ""
srcItemID := ast.NewNodeID()
if nil != src["itemID"] {
srcItemID = src["itemID"].(string)
}
isDetached := detachedSources[index]
var tree *parse.Tree
if !isDetached {
boundBlockID = src["id"].(string)
if !ast.IsNodeIDPattern(boundBlockID) {
continue
}
tree = boundTrees[boundBlockID]
}
var srcContent string
if nil != src["content"] {
srcContent = src["content"].(string)
}
if avErr := addAttributeViewBlock0(attrView, now, avID, dbBlockID, viewID, groupID, previousItemID, srcItemID, boundBlockID, srcContent, src, isDetached, ignoreDefaultFill, databaseScope, tree, tx, result, collectionRuleIDs...); nil != avErr {
err = avErr
return
}
}
regenAttrViewGroups(attrView)
err = av.SaveAttributeView(attrView)
return
}
func addAttributeViewBlock(now int64, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent string, src map[string]any, isDetached, ignoreDefaultFill bool, tree *parse.Tree, tx *Transaction, result *insertAttrViewBlockResult) (err error) {
attrView, err := avParseView(avID, dbBlockID)
if err != nil {
return
}
if err = addAttributeViewBlock0(attrView, now, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent, src, isDetached, ignoreDefaultFill, false, tree, tx, result); nil != err {
return
}
regenAttrViewGroups(attrView)
err = av.SaveAttributeView(attrView)
return
}
func addAttributeViewBlock0(attrView *av.AttributeView, now int64, avID, dbBlockID, viewID, groupID, previousItemID, addingItemID, addingBoundBlockID, addingBlockContent string, src map[string]any, isDetached, ignoreDefaultFill, databaseScope bool, tree *parse.Tree, tx *Transaction, result *insertAttrViewBlockResult, collectionRuleIDs ...string) (err error) {
var node *ast.Node
if !isDetached {
if err = validateAttributeViewBinding(avID, tree); err != nil {
return
}
node = treenode.GetNodeInTree(tree, addingBoundBlockID)
if nil == node {
err = ErrBlockNotFound
return
}
} else {
if "" == addingItemID {
addingItemID = ast.NewNodeID()
logging.LogWarnf("detached block id is empty, generate a new one [%s]", addingItemID)
}
}
var blockIcon string
var blockRefSubtype av.BlockRefSubtype
if !isDetached {
blockIcon, addingBlockContent = getNodeAvBlockText(node, avID)
blockRefSubtype = getNodeAvBlockRefSubtype(node, avID)
addingBlockContent = util.UnescapeHTML(addingBlockContent)
}
// 检查是否重复添加相同的块
blockValues := attrView.GetBlockKeyValues()
if nil == blockValues || nil == blockValues.Key {
return fmt.Errorf("attribute view [%s] has no block key", avID)
}
for _, blockValue := range blockValues.Values {
if nil == blockValue || nil == blockValue.Block {
continue
}
if "" != addingBoundBlockID && blockValue.Block.ID == addingBoundBlockID {
if !isDetached {
// 重复绑定一下,比如剪切数据库块、取消绑定块后再次添加的场景需要
bindBlockAv0(tx, avID, node, tree)
blockValue.IsDetached = isDetached
blockValue.Block.Icon = blockIcon
blockValue.Block.Content = addingBlockContent
blockValue.Block.RefSubtype = blockRefSubtype
blockValue.UpdatedAt = now
}
msg := fmt.Sprintf(Conf.language(269), util.EscapeHTML(getAttrViewName(attrView)))
util.PushMsg(msg, 5000)
src["itemID"] = blockValue.BlockID
if nil == err {
result.ExistingItemIDs = append(result.ExistingItemIDs, blockValue.BlockID)
}
return
}
}
blockValue := &av.Value{
ID: ast.NewNodeID(),
KeyID: blockValues.Key.ID,
BlockID: addingItemID,
Type: av.KeyTypeBlock,
IsDetached: isDetached,
CreatedAt: now,
UpdatedAt: now,
Block: &av.ValueBlock{Icon: blockIcon, Content: addingBlockContent, RefSubtype: blockRefSubtype, Created: now, Updated: now}}
if !isDetached {
blockValue.Block.ID = addingBoundBlockID
if len(collectionRuleIDs) > 0 {
blockValue.Block.CollectionRuleID = collectionRuleIDs[0]
}
}
blockValues.Values = append(blockValues.Values, blockValue)
viewBlockID := dbBlockID
if databaseScope {
viewBlockID = ""
}
view, err := getAttrViewViewByBlockID(attrView, viewBlockID)
if nil != err {
logging.LogErrorf("get view by block ID [%s] failed: %s", dbBlockID, err)
return
}
if "" != viewID {
view = attrView.GetView(viewID)
if nil == view {
logging.LogErrorf("get view by view ID [%s] failed", viewID)
return av.ErrViewNotFound
}
}
groupView := view
if "" != groupID {
groupView = view.GetGroupByID(groupID)
}
useGroupDefault := "" != groupID
var filterContext *av.FilterContext
if !databaseScope {
filterContext, err = resolveAttributeViewFilterContext(attrView, view, dbBlockID)
if err != nil {
return err
}
}
if nil != filterContext && 1 > len(filterContext.CurrentDocumentItemIDs) {
return av.ErrAttributeViewContextNotBound
}
if !ignoreDefaultFill {
if err = fillDefaultValue(attrView, view, groupView, previousItemID, addingItemID, true, useGroupDefault,
dbBlockID, filterContext); nil != err {
return
}
} else {
if err = fillAttributeViewContextFilterValue(attrView, groupView, addingItemID, filterContext,
dbBlockID); nil != err {
return
}
}
// 处理日期字段默认填充当前创建时间
// The database date field supports filling the current time by default https://github.com/siyuan-note/siyuan/issues/10823
fillAttrViewAutoFillNowValues(attrView, addingItemID, isDetached, now)
if !isDetached {
bindBlockAv0(tx, avID, node, tree)
}
// 在所有视图上添加项目
for _, v := range attrView.Views {
if "" != previousItemID {
changed := false
for i, id := range v.ItemIDs {
if id == previousItemID {
v.ItemIDs = append(v.ItemIDs[:i+1], append([]string{addingItemID}, v.ItemIDs[i+1:]...)...)
changed = true
break
}
}
if !changed {
v.ItemIDs = append(v.ItemIDs, addingItemID)
}
} else {
v.ItemIDs = append([]string{addingItemID}, v.ItemIDs...)
}
// 在所有分组视图中添加,目的是为了在重新分组的过程中保住排序状态 https://github.com/siyuan-note/siyuan/issues/15560
for _, g := range v.Groups {
if "" != previousItemID {
changed := false
for i, id := range g.GroupItemIDs {
if id == previousItemID {
g.GroupItemIDs = append(g.GroupItemIDs[:i+1], append([]string{addingItemID}, g.GroupItemIDs[i+1:]...)...)
changed = true
break
}
}
if !changed {
g.GroupItemIDs = append(g.GroupItemIDs, addingItemID)
}
} else {
g.GroupItemIDs = append([]string{addingItemID}, g.GroupItemIDs...)
}
}
}
result.InsertedItemIDs = append(result.InsertedItemIDs, addingItemID)
return
}
func fillAttrViewAutoFillNowValues(attrView *av.AttributeView, addingItemID string, isDetached bool, now int64) {
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeDate == keyValues.Key.Type && nil != keyValues.Key.Date && keyValues.Key.Date.AutoFillNow {
val := keyValues.GetValue(addingItemID)
if nil == val {
dateVal := &av.Value{
ID: ast.NewNodeID(), KeyID: keyValues.Key.ID, BlockID: addingItemID, Type: av.KeyTypeDate, IsDetached: isDetached, CreatedAt: now, UpdatedAt: now + 1000,
Date: &av.ValueDate{Content: now, IsNotEmpty: true, IsNotTime: !keyValues.Key.Date.FillSpecificTime},
}
keyValues.Values = append(keyValues.Values, dateVal)
} else {
if nil == val.Date {
val.Date = &av.ValueDate{}
}
val.CreatedAt, val.UpdatedAt = now, now+1000
val.Date.Content, val.Date.IsNotEmpty, val.Date.IsNotTime = now, true, !keyValues.Key.Date.FillSpecificTime
val.IsRenderAutoFill = false
}
}
}
}
func fillDefaultValue(attrView *av.AttributeView, view, groupView *av.View, previousItemID, addingItemID string,
isCreate, useGroupDefault bool, blockID string, filterContexts ...*av.FilterContext) (err error) {
filterContext := firstAttributeViewFilterContext(filterContexts)
defaultValues := getAttrViewAddingBlockDefaultValues(attrView, view, groupView, previousItemID, addingItemID,
isCreate, useGroupDefault, filterContext)
err = writeAttributeViewDefaultValues(attrView, groupView, addingItemID, defaultValues, blockID)
return
}
func fillAttributeViewContextFilterValue(attrView *av.AttributeView, groupView *av.View, addingItemID string,
filterContext *av.FilterContext, blockID string) (err error) {
defaultValues := map[string]*av.Value{}
applyAttributeViewContextFilterDefaultValue(attrView, addingItemID, filterContext, defaultValues)
err = writeAttributeViewDefaultValues(attrView, groupView, addingItemID, defaultValues, blockID)
return
}
func writeAttributeViewDefaultValues(attrView *av.AttributeView, groupView *av.View, addingItemID string,
defaultValues map[string]*av.Value, blockID string) (err error) {
for keyID, newValue := range defaultValues {
newValue.BlockID = addingItemID
keyValues, getErr := attrView.GetKeyValues(keyID)
if nil != getErr {
continue
}
if av.KeyTypeRollup == newValue.Type {
// 汇总字段的值是渲染时计算的,不需要添加到数据存储中
continue
}
if nil != groupView && (av.KeyTypeSelect == newValue.Type || av.KeyTypeMSelect == newValue.Type) &&
1 > len(newValue.MSelect) && groupValueDefault != groupView.GetGroupValue() {
// 单选或多选类型的值可能需要从分组条件中获取默认值
if opt := keyValues.Key.GetOption(groupView.GetGroupValue()); nil != opt {
newValue.MSelect = append(newValue.MSelect, newAttrViewValueSelect(opt))
}
}
if av.KeyTypeRelation == newValue.Type && nil != keyValues.Key.Relation && keyValues.Key.Relation.IsTwoWay {
// 双向关联需要同时更新目标字段的值
if err = updateTwoWayRelationDestAttrViewInBlock(attrView, keyValues.Key, newValue, 1, []string{},
blockID); nil != err {
return
}
}
existingVal := keyValues.GetValue(addingItemID)
if nil == existingVal {
newValue.IsRenderAutoFill = false
keyValues.Values = append(keyValues.Values, newValue)
} else {
newValueRaw := newValue.GetValByType(keyValues.Key.Type)
if av.KeyTypeBlock != existingVal.Type || (av.KeyTypeBlock == existingVal.Type && existingVal.IsDetached) {
// 非主键的值直接覆盖,主键的值只覆盖非绑定块
existingVal.IsRenderAutoFill = false
existingVal.SetValByType(keyValues.Key.Type, newValueRaw)
}
}
}
return
}
func getNewValueByNearItem(nearItem av.Item, key *av.Key, addingBlockID string) (ret *av.Value) {
if nil == nearItem {
return
}
defaultVal := nearItem.GetValue(key.ID)
if nil == defaultVal {
return
}
ret = defaultVal.Clone()
if nil == ret {
return
}
ret.ID = ast.NewNodeID()
ret.KeyID = key.ID
ret.BlockID = addingBlockID
ret.CreatedAt = util.CurrentTimeMillis()
ret.UpdatedAt = ret.CreatedAt + 1000
return
}
func getNearItem(attrView *av.AttributeView, view, groupView *av.View, previousItemID string,
filterContexts ...*av.FilterContext) (ret av.Item) {
// 邻近条目查找会过滤和排序缓存,完成后清除临时结果,确保默认值写入后按完整数据重新生成分组。
defer clear(attrView.RenderedViewables)
cachedAttrViews := map[string]*av.AttributeView{}
rollupFurtherCollections := sql.GetFurtherCollections(attrView, cachedAttrViews)
viewable := sql.RenderGroupView(attrView, view, groupView, "")
av.FilterWithContext(viewable, attrView, rollupFurtherCollections, cachedAttrViews,
firstAttributeViewFilterContext(filterContexts))
av.Sort(viewable, attrView)
items := viewable.(av.Collection).GetItems()
if 0 < len(items) {
if "" != previousItemID {
for _, row := range items {
if row.GetID() == previousItemID {
ret = row
return
}
}
} else {
if 0 < len(items) {
ret = items[0]
return
}
}
}
return
}
func (tx *Transaction) doRemoveAttrViewBlock(operation *Operation) (ret *TxErr) {
if err := tx.prepareAttributeViewItemRemoval(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
err := removeAttributeViewBlock(operation.SrcIDs, operation.AvID, operation.BlockID, tx)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func RemoveAttributeViewBlock(srcIDs []string, avID string) (err error) {
err = removeAttributeViewBlock(srcIDs, avID, "", nil)
return
}
func removeAttributeViewBlock(srcIDs []string, avID, blockID string, tx *Transaction) (err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
relationDestAvIDs := map[string]bool{}
for _, keyValues := range attrView.KeyValues {
if av.KeyTypeRelation != keyValues.Key.Type || nil == keyValues.Key.Relation {
continue
}
for _, value := range keyValues.Values {
if gulu.Str.Contains(value.BlockID, srcIDs) {
relationDestAvIDs[keyValues.Key.Relation.AvID] = true
break
}
}
}
trees := map[string]*parse.Tree{}
removedValues := false
for _, keyValues := range attrView.KeyValues {
tmp := keyValues.Values[:0]
for i, val := range keyValues.Values {
if !gulu.Str.Contains(val.BlockID, srcIDs) {
tmp = append(tmp, keyValues.Values[i])
} else {
removedValues = true
if av.KeyTypeRelation == keyValues.Key.Type && nil != keyValues.Key.Relation &&
keyValues.Key.Relation.IsTwoWay && nil != val.Relation && 0 < len(val.Relation.BlockIDs) {
clearedValue := val.Clone()
oldRelationBlockIDs := append([]string(nil), val.Relation.BlockIDs...)
clearedValue.Relation.BlockIDs = nil
if err = updateTwoWayRelationDestAttrViewInBlock(attrView, keyValues.Key, clearedValue, 2,
oldRelationBlockIDs, blockID); nil != err {
return
}
tx.invalidateAttributeViewHistory(keyValues.Key.Relation.AvID)
}
// Remove av block also remove node attr https://github.com/siyuan-note/siyuan/issues/9091#issuecomment-1709824006
if !val.IsDetached && nil != val.Block {
bt := attributeViewBindingBlockTree(val.Block.ID, av.GetAVBoxID(avID))
if bt != nil && (tx == nil || tx.trees[bt.RootID] == nil) {
if _, statErr := os.Stat(filepath.Join(util.DataDir, bt.BoxID, bt.Path)); statErr != nil {
if !errors.Is(statErr, os.ErrNotExist) {
return statErr
}
bt = nil
}
}
if nil != bt {
tree := trees[bt.RootID]
if nil == tree {
if nil != tx {
tree, _ = tx.loadTree(val.Block.ID)
} else {
tree, _ = LoadTreeByBlockID(val.Block.ID)
}
}
if nil != tree {
trees[bt.RootID] = tree
if node := treenode.GetNodeInTree(tree, val.Block.ID); nil != node {
if err = removeNodeAvID(node, avID, tx, tree); err != nil {
return
}
}
}
}
}
}
}
keyValues.Values = tmp
}
for _, view := range attrView.Views {
for _, blockID := range srcIDs {
view.ItemIDs = gulu.Str.RemoveElem(view.ItemIDs, blockID)
}
}
for _, itemID := range srcIDs {
attrView.RemoveCardCoverPositions(itemID)
}
attrView.RemoveNewItemTemplateRelationItems(avID, srcIDs)
attrView.RemoveRelationFilterItems(avID, srcIDs)
regenAttrViewGroups(attrView)
err = avSaveView(attrView, blockID)
if nil != err {
return
}
if removedValues {
tx.invalidateAttributeViewHistory(avID)
}
if err = removeRelatedRelationItems(avID, srcIDs, blockID, tx); nil != err {
return
}
refreshRelatedSrcAvsInBlock(avID, blockID, tx)
for destAvID := range relationDestAvIDs {
if "" != destAvID && destAvID != avID {
ReloadAttrView(destAvID)
}
}
historyDir, err := getHistoryDir(HistoryOpUpdate)
if err != nil {
logging.LogErrorf("get history dir failed: %s", err)
return
}
blockIDs := treenode.GetMirrorAttrViewBlockIDs(avID)
carrierBoxID, exact, _ := resolveAttributeViewCarrierBoxID(blockID)
for _, mirrorBlockID := range blockIDs {
if exact {
mirrorBoxID, mirrorExact, resolveErr := resolveAttributeViewCarrierBoxID(mirrorBlockID)
if nil != resolveErr || !mirrorExact || mirrorBoxID != carrierBoxID {
continue
}
}
tree := trees[mirrorBlockID]
if nil == tree {
tree, _ = LoadTreeByBlockID(mirrorBlockID)
}
if nil == tree {
continue
}
historyPath := filepath.Join(historyDir, tree.Box, tree.Path)
absPath := filepath.Join(util.DataDir, tree.Box, tree.Path)
if err = filelock.Copy(absPath, historyPath); err != nil {
logging.LogErrorf("backup [path=%s] to history [%s] failed: %s", absPath, historyPath, err)
return
}
}
var srcAvPath string
if exact {
srcAvPath, _ = av.FindAttributeViewPathInBox(avID, carrierBoxID)
} else {
srcAvPath, _ = av.FindAttributeViewPath(avID)
}
if srcAvPath == "" {
return
}
destAvPath := filepath.Join(historyDir, "storage", "av", avID+".json")
if exact && "" != carrierBoxID {
destAvPath = filepath.Join(historyDir, carrierBoxID, "storage", "av", avID+".json")
}
if copyErr := filelock.Copy(srcAvPath, destAvPath); nil != copyErr {
logging.LogErrorf("copy av [%s] failed: %s", srcAvPath, copyErr)
}
indexHistoryDir(filepath.Base(historyDir), util.NewLute())
return
}
func removeRelatedRelationItems(avID string, itemIDs []string, blockID string, tx *Transaction) (err error) {
for _, relatedAvID := range av.GetSrcAvIDs(avID) {
if relatedAvID == avID {
continue
}
relatedAv, parseErr := avParseView(relatedAvID, blockID)
if nil != parseErr || nil == relatedAv {
continue
}
templateChanged := relatedAv.RemoveNewItemTemplateRelationItems(avID, itemIDs)
filterChanged := relatedAv.RemoveRelationFilterItems(avID, itemIDs)
if !templateChanged && !filterChanged {
continue
}
if err = avSaveView(relatedAv, blockID); nil != err {
return
}
tx.invalidateAttributeViewHistory(relatedAvID)
ReloadAttrView(relatedAvID)
}
return
}
func removeNodeAvID(node *ast.Node, avID string, tx *Transaction, tree *parse.Tree) (err error) {
attrs := removeNodeAvIDAttrs(node, avID)
if nil != tx {
if err = setNodeAttrsWithTx(tx, node, tree, attrs); err != nil {
return
}
} else {
if err = setNodeAttrs(node, tree, attrs); err != nil {
return
}
}
return
}
func removeNodeAvIDAttrs(node *ast.Node, avID string) map[string]string {
attrs := parse.IAL2Map(node.KramdownIAL)
if avs := attrs[av.NodeAttrNameAvs]; "" != avs {
avIDs := strings.Split(avs, ",")
avIDs = gulu.Str.RemoveElem(avIDs, avID)
var existAvIDs []string
for _, attributeViewID := range avIDs {
if av.IsAttributeViewExist(attributeViewID) {
existAvIDs = append(existAvIDs, attributeViewID)
}
}
avIDs = existAvIDs
if 0 == len(avIDs) {
attrs[av.NodeAttrNameAvs] = ""
} else {
attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
node.SetIALAttr(av.NodeAttrNameAvs, strings.Join(avIDs, ","))
avNames := getAvNames(node.IALAttr(av.NodeAttrNameAvs))
attrs[av.NodeAttrViewNames] = avNames
}
}
return attrs
}
func (tx *Transaction) doDuplicateAttrViewKey(operation *Operation) (ret *TxErr) {
err := duplicateAttributeViewKey(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func duplicateAttributeViewKey(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
key, _ := attrView.GetKey(operation.KeyID)
if nil == key {
return
}
if av.KeyTypeBlock == key.Type || av.KeyTypeRelation == key.Type {
return
}
copyKey := &av.Key{}
if err = copier.Copy(copyKey, key); err != nil {
logging.LogErrorf("clone key failed: %s", err)
}
copyKey.ID = operation.NextID
copyKey.Name = util.GetDuplicateName(key.Name)
attrView.KeyValues = append(attrView.KeyValues, &av.KeyValues{Key: copyKey})
for _, view := range attrView.Views {
for _, layout := range view.TableLayouts() {
if nil == layout {
continue
}
for i, column := range layout.Columns {
if column.ID != key.ID {
continue
}
cloned := &av.ViewTableColumn{}
if err = copier.CopyWithOption(cloned, column, copier.Option{DeepCopy: true}); nil != err {
return
}
cloned.ID = copyKey.ID
if layout == view.List && av.LayoutTypeList != view.LayoutType ||
view.Calendar != nil && layout == view.Calendar.LayoutTable && av.LayoutTypeCalendar != view.LayoutType {
cloned.Hidden = true
}
layout.Columns = slices.Insert(layout.Columns, i+1, cloned)
break
}
}
if nil != view.Gallery {
for i, field := range view.Gallery.CardFields {
if field.ID != key.ID {
continue
}
cloned := &av.ViewGalleryCardField{}
if err = copier.CopyWithOption(cloned, field, copier.Option{DeepCopy: true}); nil != err {
return
}
cloned.ID = copyKey.ID
view.Gallery.CardFields = slices.Insert(view.Gallery.CardFields, i+1, cloned)
break
}
}
if nil != view.Kanban {
for i, field := range view.Kanban.Fields {
if field.ID != key.ID {
continue
}
cloned := &av.ViewKanbanField{}
if err = copier.CopyWithOption(cloned, field, copier.Option{DeepCopy: true}); nil != err {
return
}
cloned.ID = copyKey.ID
view.Kanban.Fields = slices.Insert(view.Kanban.Fields, i+1, cloned)
break
}
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnWidth(operation *Operation) (ret *TxErr) {
err := setAttributeViewColWidth(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColWidth(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
switch view.LayoutType {
case av.LayoutTypeTable:
for _, column := range view.Table.Columns {
if column.ID == operation.ID {
column.Width = av.FilterWidthValue(operation.Data.(string))
break
}
}
case av.LayoutTypeGallery, av.LayoutTypeKanban:
return
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnsWidth(operation *Operation) (ret *TxErr) {
err := setAttributeViewColsWidth(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColsWidth(operation *Operation) (err error) {
widthData, ok := operation.Data.(map[string]any)
if !ok {
return fmt.Errorf("invalid attribute view column widths")
}
widths := map[string]string{}
for id, value := range widthData {
width, valueOK := value.(string)
if !valueOK {
return fmt.Errorf("invalid width for attribute view column [%s]", id)
}
widths[id] = width
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return err
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return err
}
if av.LayoutTypeTable != view.LayoutType {
return nil
}
for _, column := range view.Table.Columns {
if width, found := widths[column.ID]; found {
column.Width = av.FilterWidthValue(width)
}
}
return av.SaveAttributeView(attrView)
}
func (tx *Transaction) doSetAttrViewColumnAlign(operation *Operation) (ret *TxErr) {
err := setAttributeViewColAlign(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColAlign(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
if av.LayoutTypeTable != view.LayoutType {
return
}
alignValue, ok := operation.Data.(string)
align := av.TableColumnAlign(alignValue)
if !ok || !align.IsValid() {
return av.ErrInvalidColumnAlign
}
for _, column := range view.Table.Columns {
if column.ID == operation.ID {
column.Align = align
break
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnWrap(operation *Operation) (ret *TxErr) {
err := setAttributeViewColWrap(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColWrap(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
newWrap := operation.Data.(bool)
allFieldWrap := true
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
for _, column := range view.GetTableLayout().Columns {
if column.ID == operation.ID {
column.Wrap = newWrap
}
allFieldWrap = allFieldWrap && column.Wrap
}
view.GetTableLayout().WrapField = allFieldWrap
case av.LayoutTypeGallery:
for _, field := range view.Gallery.CardFields {
if field.ID == operation.ID {
field.Wrap = newWrap
}
allFieldWrap = allFieldWrap && field.Wrap
}
view.Gallery.WrapField = allFieldWrap
case av.LayoutTypeKanban:
for _, field := range view.Kanban.Fields {
if field.ID == operation.ID {
field.Wrap = newWrap
}
allFieldWrap = allFieldWrap && field.Wrap
}
view.Kanban.WrapField = allFieldWrap
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnHidden(operation *Operation) (ret *TxErr) {
err := setAttributeViewColHidden(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColHidden(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
viewIDs := operation.ViewIDs
if 1 > len(viewIDs) {
if "" != operation.ViewID {
viewIDs = []string{operation.ViewID}
} else {
var view *av.View
view, err = getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
viewIDs = []string{view.ID}
}
}
err = setAttributeViewFieldsHidden(attrView, operation.ID, viewIDs, operation.Data.(bool))
if err != nil {
return
}
err = av.SaveAttributeView(attrView)
return
}
func setAttributeViewFieldsHidden(attrView *av.AttributeView, keyID string, viewIDs []string, hidden bool) (err error) {
var fields []*av.BaseField
seen := map[string]bool{}
for _, viewID := range viewIDs {
if seen[viewID] {
continue
}
seen[viewID] = true
view := attrView.GetView(viewID)
if nil == view {
return fmt.Errorf("view [%s] not found", viewID)
}
if hidden && (av.LayoutTypeList == view.LayoutType || av.LayoutTypeCalendar == view.LayoutType) {
key, keyErr := attrView.GetKey(keyID)
if nil != keyErr {
return keyErr
}
if av.KeyTypeBlock == key.Type {
return errors.New("cannot hide the primary key in a list view")
}
}
field := getAttributeViewField(view, keyID)
if nil == field {
return fmt.Errorf("field [%s] not found in view [%s]", keyID, viewID)
}
fields = append(fields, field)
}
if 1 > len(fields) {
return errors.New("view IDs is empty")
}
for _, field := range fields {
field.Hidden = hidden
}
return
}
func getAttributeViewField(view *av.View, keyID string) (ret *av.BaseField) {
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
if nil == view.GetTableLayout() {
return
}
for _, column := range view.GetTableLayout().Columns {
if column.ID == keyID {
return column.BaseField
}
}
case av.LayoutTypeGallery:
if nil == view.Gallery {
return
}
for _, field := range view.Gallery.CardFields {
if field.ID == keyID {
return field.BaseField
}
}
case av.LayoutTypeKanban:
if nil == view.Kanban {
return
}
for _, field := range view.Kanban.Fields {
if field.ID == keyID {
return field.BaseField
}
}
}
return
}
func (tx *Transaction) doSetAttrViewColumnPin(operation *Operation) (ret *TxErr) {
err := setAttributeViewColPin(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColPin(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
switch view.LayoutType {
case av.LayoutTypeTable:
pin := operation.Data.(bool)
for _, column := range view.Table.Columns {
column.Pin = pin && column.ID == operation.ID
}
case av.LayoutTypeGallery, av.LayoutTypeKanban:
return
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnIcon(operation *Operation) (ret *TxErr) {
err := setAttributeViewColIcon(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColIcon(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID == operation.ID {
keyValues.Key.Icon = filterAttrViewIconValue(operation.Data.(string))
break
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColumnDesc(operation *Operation) (ret *TxErr) {
err := setAttributeViewColDesc(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColDesc(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID == operation.ID {
keyValues.Key.Desc = operation.Data.(string)
break
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSortAttrViewRow(operation *Operation) (ret *TxErr) {
err := tx.sortAttributeViewItem(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func sortAttributeViewRow(operation *Operation) (err error) {
rowOrderOperation := isAttributeViewRowOrderOperation(operation.Data)
if !rowOrderOperation && operation.ID == operation.PreviousID {
// 拖拽到自己的下方,不做任何操作 https://github.com/siyuan-note/siyuan/issues/11048
return
}
attrView, err := avParseView(operation.AvID, operation.BlockID)
if err != nil {
return
}
var view *av.View
if "" != operation.ViewID {
view = attrView.GetView(operation.ViewID)
if nil == view {
return av.ErrViewNotFound
}
} else {
view, err = getAttrViewViewByBlockID(attrView, operation.BlockID)
if err != nil {
return
}
}
if rowOrderOperation {
if err = applyAttributeViewRowOrder(attrView, view, operation.Data); nil != err {
return err
}
return avSaveView(attrView, operation.BlockID)
}
var itemID string
var idx, previousIndex int
if nil != view.Group && "" != operation.GroupID {
if groupView := view.GetGroupByID(operation.GroupID); nil != groupView {
groupKey := view.GetGroupKey(attrView)
isAcrossGroup := operation.GroupID != operation.TargetGroupID
if isAcrossGroup && (av.ValueSourceRendered == view.Group.ValueSource || av.KeyTypeTemplate == groupKey.Type ||
av.KeyTypeCreated == groupKey.Type || av.KeyTypeUpdated == groupKey.Type) {
// 这些字段类型不支持跨分组移动,因为它们的值是自动计算生成的
return
}
for i, id := range groupView.GroupItemIDs {
if id == operation.ID {
itemID = id
idx = i
break
}
}
if "" == itemID {
itemID = operation.ID
groupView.GroupItemIDs = append(groupView.GroupItemIDs, itemID)
idx = len(groupView.GroupItemIDs) - 1
}
groupView.GroupItemIDs = append(groupView.GroupItemIDs[:idx], groupView.GroupItemIDs[idx+1:]...)
if isAcrossGroup {
if targetGroupView := view.GetGroupByID(operation.TargetGroupID); nil != targetGroupView && !gulu.Str.Contains(itemID, targetGroupView.GroupItemIDs) {
filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, operation.BlockID)
if nil != contextErr {
return contextErr
}
if err = fillDefaultValue(attrView, view, targetGroupView, operation.PreviousID, itemID, false,
true, operation.BlockID, filterContext); nil != err {
return
}
if val := attrView.GetValue(groupKey.ID, itemID); nil != val {
if av.MSelectExistOption(val.MSelect, groupView.GetGroupValue()) {
// 移除旧分组的值
val.MSelect = av.MSelectRemoveOption(val.MSelect, groupView.GetGroupValue())
}
now := time.Now().UnixMilli()
val.SetUpdatedAt(now)
if blockVal := attrView.GetBlockValue(itemID); nil != blockVal {
blockVal.Block.Updated = now
blockVal.SetUpdatedAt(now)
}
}
for i, r := range targetGroupView.GroupItemIDs {
if r == operation.PreviousID {
previousIndex = i + 1
break
}
}
targetGroupView.GroupItemIDs = slices.Insert(targetGroupView.GroupItemIDs, previousIndex, itemID)
}
regenAttrViewGroups(attrView)
} else { // 同分组内排序
for i, r := range groupView.GroupItemIDs {
if r == operation.PreviousID {
previousIndex = i + 1
break
}
}
groupView.GroupItemIDs = slices.Insert(groupView.GroupItemIDs, previousIndex, itemID)
}
}
} else {
for i, id := range view.ItemIDs {
if id == operation.ID {
itemID = id
idx = i
break
}
}
if "" == itemID {
itemID = operation.ID
view.ItemIDs = append(view.ItemIDs, itemID)
idx = len(view.ItemIDs) - 1
}
view.ItemIDs = append(view.ItemIDs[:idx], view.ItemIDs[idx+1:]...)
for i, r := range view.ItemIDs {
if r == operation.PreviousID {
previousIndex = i + 1
break
}
}
view.ItemIDs = slices.Insert(view.ItemIDs, previousIndex, itemID)
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSortAttrViewColumn(operation *Operation) (ret *TxErr) {
err := SortAttributeViewViewKey(operation.AvID, operation.BlockID, operation.ID, operation.PreviousID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func SortAttributeViewViewKey(avID, blockID, keyID, previousKeyID string) (err error) {
if keyID == previousKeyID {
// 拖拽到自己的右侧,不做任何操作 https://github.com/siyuan-note/siyuan/issues/11048
return
}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
view, err := getAttrViewViewByBlockID(attrView, blockID)
if err != nil {
return
}
var curIndex, previousIndex int
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
var col *av.ViewTableColumn
for i, column := range view.GetTableLayout().Columns {
if column.ID == keyID {
col = column
curIndex = i
break
}
}
if nil == col {
return
}
view.GetTableLayout().Columns = append(view.GetTableLayout().Columns[:curIndex], view.GetTableLayout().Columns[curIndex+1:]...)
for i, column := range view.GetTableLayout().Columns {
if column.ID == previousKeyID {
previousIndex = i + 1
break
}
}
view.GetTableLayout().Columns = slices.Insert(view.GetTableLayout().Columns, previousIndex, col)
case av.LayoutTypeGallery:
var field *av.ViewGalleryCardField
for i, cardField := range view.Gallery.CardFields {
if cardField.ID == keyID {
field = cardField
curIndex = i
break
}
}
if nil == field {
return
}
view.Gallery.CardFields = append(view.Gallery.CardFields[:curIndex], view.Gallery.CardFields[curIndex+1:]...)
for i, cardField := range view.Gallery.CardFields {
if cardField.ID == previousKeyID {
previousIndex = i + 1
break
}
}
view.Gallery.CardFields = slices.Insert(view.Gallery.CardFields, previousIndex, field)
case av.LayoutTypeKanban:
var field *av.ViewKanbanField
for i, kanbanField := range view.Kanban.Fields {
if kanbanField.ID == keyID {
field = kanbanField
curIndex = i
break
}
}
if nil == field {
return
}
view.Kanban.Fields = append(view.Kanban.Fields[:curIndex], view.Kanban.Fields[curIndex+1:]...)
for i, kanbanField := range view.Kanban.Fields {
if kanbanField.ID == previousKeyID {
previousIndex = i + 1
break
}
}
view.Kanban.Fields = slices.Insert(view.Kanban.Fields, previousIndex, field)
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSortAttrViewKey(operation *Operation) (ret *TxErr) {
err := SortAttributeViewKey(operation.AvID, operation.ID, operation.PreviousID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func SortAttributeViewKey(avID, keyID, previousKeyID string) (err error) {
if keyID == previousKeyID {
return
}
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
refreshAttrViewKeyIDs(attrView, false)
var currentKeyID string
var idx, previousIndex int
for i, k := range attrView.KeyIDs {
if k == keyID {
currentKeyID = k
idx = i
break
}
}
if "" == currentKeyID {
return
}
attrView.KeyIDs = append(attrView.KeyIDs[:idx], attrView.KeyIDs[idx+1:]...)
for i, k := range attrView.KeyIDs {
if k == previousKeyID {
previousIndex = i + 1
break
}
}
attrView.KeyIDs = slices.Insert(attrView.KeyIDs, previousIndex, currentKeyID)
err = av.SaveAttributeView(attrView)
return
}
func refreshAttrViewKeyIDs(attrView *av.AttributeView, needSave bool) {
// 订正 keyIDs 数据
existKeyIDs := map[string]bool{}
for _, keyValues := range attrView.KeyValues {
existKeyIDs[keyValues.Key.ID] = true
}
for k := range existKeyIDs {
if !gulu.Str.Contains(k, attrView.KeyIDs) {
attrView.KeyIDs = append(attrView.KeyIDs, k)
}
}
var tmp []string
for _, k := range attrView.KeyIDs {
if ok := existKeyIDs[k]; ok {
tmp = append(tmp, k)
}
}
attrView.KeyIDs = tmp
if needSave {
av.SaveAttributeView(attrView)
}
}
func (tx *Transaction) doAddAttrViewColumn(operation *Operation) (ret *TxErr) {
if operation.attributeViewFields != nil {
if err := tx.replayAttributeViewFields(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
var icon string
if nil != operation.Data {
icon = operation.Data.(string)
}
err := AddAttributeViewKey(operation.AvID, operation.BlockID, operation.ID, operation.Name, operation.Typ, icon, operation.PreviousID,
av.DateDisplayFormat(operation.Format))
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func AddAttributeViewKey(avID, blockID, keyID, keyName, keyType, keyIcon, previousKeyID string, dateFormat av.DateDisplayFormat) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
currentView, err := getAttrViewViewByBlockID(attrView, blockID)
if nil != err {
return
}
key, err := newAttributeViewKey(keyID, keyName, keyType, keyIcon, dateFormat)
if nil != err {
return err
}
addAttributeViewKey(attrView, currentView, key, previousKeyID)
err = av.SaveAttributeView(attrView)
return
}
func newAttributeViewKey(keyID, keyName, keyType, keyIcon string, dateFormat av.DateDisplayFormat) (ret *av.Key, err error) {
keyTyp := av.KeyType(keyType)
if av.KeyTypeBlock == keyTyp {
return nil, errors.New("cannot add an attribute view block key")
}
if !av.IsKnownKeyType(keyTyp) {
return nil, fmt.Errorf("unsupported attribute view key type [%s]", keyType)
}
ret = av.NewKey(keyID, keyName, filterAttrViewIconValue(keyIcon), keyTyp)
if av.IsDateKeyType(keyTyp) {
if !dateFormat.IsValid() {
return nil, errors.New("invalid date display format")
}
if dateFormat == av.DateDisplayFormatLunar && keyTyp != av.KeyTypeDate {
return nil, errors.New("lunar calendar is only available for date fields")
}
ret.DateFormat = dateFormat
}
if av.KeyTypeRollup == keyTyp {
ret.Rollup = &av.Rollup{Calc: &av.RollupCalc{Operator: av.CalcOperatorNone}}
}
return
}
func addAttributeViewKey(attrView *av.AttributeView, currentView *av.View, key *av.Key, previousKeyID string) {
attrView.KeyValues = append(attrView.KeyValues, &av.KeyValues{Key: key})
for _, view := range attrView.Views {
if nil != view.Calendar {
hidden := nil == currentView || currentView.ID != view.ID || av.LayoutTypeCalendar != currentView.LayoutType
column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: key.ID, Hidden: hidden, Wrap: view.Calendar.WrapField}}
index := len(view.Calendar.Columns)
for i, field := range view.Calendar.Columns {
if field.ID == previousKeyID {
index = i + 1
break
}
}
view.Calendar.Columns = slices.Insert(view.Calendar.Columns, index, column)
}
if nil != view.List {
hidden := nil == currentView || currentView.ID != view.ID || av.LayoutTypeList != currentView.LayoutType
column := &av.ViewTableColumn{BaseField: &av.BaseField{ID: key.ID, Hidden: hidden, Wrap: view.List.WrapField}}
index := len(view.List.Columns)
for i, field := range view.List.Columns {
if field.ID == previousKeyID {
index = i + 1
break
}
}
view.List.Columns = slices.Insert(view.List.Columns, index, column)
}
if nil != view.Table {
newField := &av.BaseField{ID: key.ID, Wrap: view.Table.WrapField}
if "" == previousKeyID {
if nil == currentView || av.LayoutTypeTable != currentView.LayoutType {
// 非表格视图新增的字段追加到表格末尾。
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: newField})
} else {
view.Table.Columns = append([]*av.ViewTableColumn{{BaseField: newField}}, view.Table.Columns...)
}
} else {
added := false
for i, column := range view.Table.Columns {
if column.ID == previousKeyID {
view.Table.Columns = append(view.Table.Columns[:i+1], append([]*av.ViewTableColumn{{BaseField: newField}}, view.Table.Columns[i+1:]...)...)
added = true
break
}
}
if !added {
view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: newField})
}
}
}
if nil != view.Gallery {
newField := &av.BaseField{ID: key.ID, Wrap: view.Gallery.WrapField}
if "" == previousKeyID {
view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: newField})
} else {
added := false
for i, field := range view.Gallery.CardFields {
if field.ID == previousKeyID {
view.Gallery.CardFields = append(view.Gallery.CardFields[:i+1], append([]*av.ViewGalleryCardField{{BaseField: newField}}, view.Gallery.CardFields[i+1:]...)...)
added = true
break
}
}
if !added {
view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: newField})
}
}
}
if nil != view.Kanban {
newField := &av.BaseField{ID: key.ID, Wrap: view.Kanban.WrapField}
if "" == previousKeyID {
view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
} else {
added := false
for i, field := range view.Kanban.Fields {
if field.ID == previousKeyID {
view.Kanban.Fields = append(view.Kanban.Fields[:i+1], append([]*av.ViewKanbanField{{BaseField: newField}}, view.Kanban.Fields[i+1:]...)...)
added = true
break
}
}
if !added {
view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
}
}
}
}
}
func (tx *Transaction) doUpdateAttrViewColTemplate(operation *Operation) (ret *TxErr) {
err := updateAttributeViewColTemplate(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColTemplate(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
templateContent, ok := operation.Data.(string)
if !ok {
return errors.New("invalid attribute view field template")
}
colType := av.KeyType(operation.Typ)
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID != operation.ID || keyValues.Key.Type != colType {
continue
}
if av.KeyTypeTemplate == colType {
keyValues.Key.Template = templateContent
} else {
keyValues.Key.RenderTemplate = templateContent
}
break
}
regenAttrViewGroups(attrView)
err = av.SaveAttributeView(attrView)
return
}
// SetAttributeViewKeyTemplate 设置模板字段公式,复用字段模板保存和分组更新逻辑。
func SetAttributeViewKeyTemplate(avID, keyID, templateContent string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if nil != err {
return err
}
key, err := attrView.GetKey(keyID)
if nil != err {
return err
}
if av.KeyTypeTemplate != key.Type {
return errors.New("key must be a template field")
}
return updateAttributeViewColTemplate(&Operation{
AvID: avID, ID: keyID, Typ: string(av.KeyTypeTemplate), Data: templateContent,
})
}
func (tx *Transaction) doUpdateAttrViewColNumberFormat(operation *Operation) (ret *TxErr) {
err := updateAttributeViewColNumberFormat(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColNumberFormat(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
colType := av.KeyType(operation.Typ)
switch colType {
case av.KeyTypeNumber:
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID == operation.ID && av.KeyTypeNumber == keyValues.Key.Type {
keyValues.Key.NumberFormat = av.NumberFormat(operation.Format)
break
}
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doSetAttrViewColDateFormat(operation *Operation) (ret *TxErr) {
err := setAttributeViewColDateFormat(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColDateFormat(operation *Operation) (err error) {
format := av.DateDisplayFormat(operation.Format)
if !format.IsValid() {
return errors.New("invalid date display format")
}
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
colType := av.KeyType(operation.Typ)
if !av.IsDateKeyType(colType) {
return errors.New("date display format is only available for date fields")
}
if format == av.DateDisplayFormatLunar && colType != av.KeyTypeDate {
return errors.New("lunar calendar is only available for date fields")
}
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID == operation.ID && keyValues.Key.Type == colType {
keyValues.Key.DateFormat = format
break
}
}
err = av.SaveAttributeView(attrView)
return
}
func (tx *Transaction) doUpdateAttrViewColumn(operation *Operation) (ret *TxErr) {
err := updateAttributeViewColumn(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColumn(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
colType := av.KeyType(operation.Typ)
changeType := false
if av.IsKnownKeyType(colType) {
for _, keyValues := range attrView.KeyValues {
if keyValues.Key.ID == operation.ID {
isPrimaryKey := av.KeyTypeBlock == keyValues.Key.Type
if isPrimaryKey != (av.KeyTypeBlock == colType) {
if isPrimaryKey {
err = errors.New("cannot change type of primary key field")
} else {
err = errors.New("cannot change field type to primary key")
}
return
}
keyValues.Key.Name = strings.TrimSpace(operation.Name)
changeType = keyValues.Key.Type != colType
keyValues.Key.Type = colType
for _, value := range keyValues.Values {
value.Type = colType
}
break
}
}
}
if changeType {
attrView.RemoveNewItemTemplateFieldValue(operation.ID)
for _, view := range attrView.Views {
if nil != view.Group {
if groupKey := view.GetGroupKey(attrView); nil != groupKey && groupKey.ID == operation.ID {
removeAttributeViewGroup0(view)
}
}
}
removeAttrViewColumnFromFieldFilters(attrView, attrView.ID, operation.ID)
}
if err = av.SaveAttributeView(attrView); nil != err {
return
}
if changeType {
relatedAvIDs := av.GetSrcAvIDs(attrView.ID)
for _, relatedAvID := range relatedAvIDs {
if relatedAvID == attrView.ID {
continue
}
destAv, _ := av.ParseAttributeView(relatedAvID)
if nil == destAv {
continue
}
for _, keyValues := range destAv.KeyValues {
if av.KeyTypeRollup == keyValues.Key.Type && nil != keyValues.Key.Rollup &&
keyValues.Key.Rollup.KeyID == operation.ID {
// 置空关联过来的汇总
for _, val := range keyValues.Values {
val.Rollup.Contents = nil
}
keyValues.Key.Rollup.Calc = &av.RollupCalc{Operator: av.CalcOperatorNone}
}
}
removeAttrViewColumnFromFieldFilters(destAv, attrView.ID, operation.ID)
regenAttrViewGroups(destAv)
av.SaveAttributeView(destAv)
ReloadAttrView(destAv.ID)
}
}
return
}
func (tx *Transaction) doRemoveAttrViewColumn(operation *Operation) (ret *TxErr) {
var err error
if operation.attributeViewFields != nil {
err = tx.replayAttributeViewFields(operation)
} else {
err = tx.removeAttributeViewField(operation)
}
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func RemoveAttributeViewKey(avID, keyID string, removeRelationDest bool) (err error) {
tx := &Transaction{trees: map[string]*parse.Tree{}}
defer func() { tx.finishAttributeViewMutation(err != nil) }()
return tx.removeAttributeViewField(&Operation{AvID: avID, ID: keyID, RemoveDest: removeRelationDest})
}
func (tx *Transaction) doReplaceAttrViewBlock(operation *Operation) (ret *TxErr) {
if err := tx.replaceAttributeViewBinding(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func replaceAttributeViewBlock(avID, oldBlockID, newBlockID string, isDetached bool, tx *Transaction) (targetItemID string, duplicate bool, err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
if targetItemID, duplicate, err = replaceAttributeViewBlock0(attrView, oldBlockID, newBlockID, isDetached, tx); nil != err {
return
}
if err = av.SaveAttributeView(attrView); nil != err {
return
}
return
}
func replaceAttributeViewBlock0(attrView *av.AttributeView, oldBlockID, newNodeID string, isDetached bool, tx *Transaction) (targetItemID string, duplicate bool, err error) {
avID := attrView.ID
targetItemID = oldBlockID
var tree *parse.Tree
var node *ast.Node
if !isDetached {
node, tree, _ = getNodeByBlockID(tx, newNodeID)
if err = validateAttributeViewBinding(avID, tree); err != nil {
return
}
}
now := util.CurrentTimeMillis()
// 检查是否已经存在绑定块,如果存在的话则重新绑定
for _, blockVal := range attrView.GetBlockKeyValues().Values {
if !isDetached && blockVal.Block.ID == newNodeID && nil != node && nil != tree {
bindBlockAv0(tx, avID, node, tree)
blockVal.IsDetached = false
icon, content := getNodeAvBlockText(node, avID)
content = util.UnescapeHTML(content)
blockVal.Block.Icon, blockVal.Block.Content = icon, content
blockVal.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
blockVal.UpdatedAt = now
regenAttrViewGroups(attrView)
targetItemID = blockVal.BlockID
duplicate = blockVal.BlockID != oldBlockID
return
}
}
for _, blockVal := range attrView.GetBlockKeyValues().Values {
if blockVal.BlockID != oldBlockID {
continue
}
if av.KeyTypeBlock == blockVal.Type {
if !isDetached {
if err = inheritAttributeViewBlockIcon(tx, node, tree, blockVal.Block.Icon); err != nil {
return
}
}
blockVal.IsDetached = isDetached
blockVal.Block.CollectionRuleID = ""
if !isDetached {
if "" != blockVal.Block.ID && blockVal.Block.ID != newNodeID {
unbindBlockAv(tx, avID, blockVal.Block.ID)
}
bindBlockAv(tx, avID, newNodeID)
blockVal.Block.ID = newNodeID
icon, content := getNodeAvBlockText(node, avID)
content = util.UnescapeHTML(content)
blockVal.Block.Icon, blockVal.Block.Content = icon, content
blockVal.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
refreshRelatedSrcAvs(avID, tx)
} else {
blockVal.Block.ID = ""
blockVal.Block.RefSubtype = ""
}
}
}
regenAttrViewGroups(attrView)
return
}
func BatchReplaceAttributeViewBlocks(avID string, isDetached bool, oldNew []map[string]string) (err error) {
attrView, err := av.ParseAttributeView(avID)
if err != nil {
return
}
if !isDetached {
for _, replacements := range oldNew {
for _, nodeID := range replacements {
_, tree, loadErr := getNodeByBlockID(nil, nodeID)
if loadErr != nil {
return loadErr
}
if err = validateAttributeViewBinding(avID, tree); err != nil {
return
}
}
}
}
for _, oldNewMap := range oldNew {
for oldBlockID, newNodeID := range oldNewMap {
if _, _, err = replaceAttributeViewBlock0(attrView, oldBlockID, newNodeID, isDetached, nil); nil != err {
return
}
}
}
if err = av.SaveAttributeView(attrView); nil != err {
return
}
return
}
func (tx *Transaction) doUpdateAttrViewCell(operation *Operation) (ret *TxErr) {
_, err := updateAttributeViewCellInBlock(tx, operation.AvID, operation.BlockID, operation.KeyID,
operation.RowID, operation.Data)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doBatchUpdateAttrViewCells(operations []*Operation) (ret *TxErr) {
attrView, err := avParseView(operations[0].AvID, operations[0].BlockID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operations[0].AvID, msg: err.Error()}
}
var cells []*AttrViewCellUpdate
for _, operation := range operations {
cells = append(cells, &AttrViewCellUpdate{KeyID: operation.KeyID, RowID: operation.RowID, Data: operation.Data})
}
if err = preflightAttributeViewCellBindings(tx, attrView, cells); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
}
for _, operation := range operations {
if _, err = updateAttributeViewValue(tx, attrView, operation.KeyID, operation.RowID, operation.Data, false,
operations[0].BlockID); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
}
regenAttrViewGroups(attrView)
if err = avSaveView(attrView, operations[0].BlockID); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
}
refreshRelatedSrcAvsInBlock(attrView.ID, operations[0].BlockID, tx)
return
}
func (tx *Transaction) doUpdateAttrViewCells(operation *Operation) (ret *TxErr) {
if "" == operation.AvID || 0 == len(operation.CellUpdates) {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "invalid attribute view cell updates"}
}
attrView, err := avParseView(operation.AvID, operation.BlockID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
if err = preflightAttributeViewCellBindings(tx, attrView, operation.CellUpdates); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
}
context := newAttrViewValueUpdateContext(attrView)
for _, cell := range operation.CellUpdates {
if nil == cell || "" == cell.KeyID || "" == cell.RowID {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: "invalid attribute view cell update"}
}
if _, err = updateAttributeViewValue0(tx, attrView, cell.KeyID, cell.RowID, cell.Data, false, context,
operation.BlockID); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
}
regenAttrViewGroups(attrView)
if err = avSaveView(attrView, operation.BlockID); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: attrView.ID, msg: err.Error()}
}
refreshRelatedSrcAvsInBlock(attrView.ID, operation.BlockID, tx)
return
}
func UpdateAttributeViewCell(tx *Transaction, avID, keyID, itemID string, valueData any) (val *av.Value, err error) {
return updateAttributeViewCellInBlock(tx, avID, "", keyID, itemID, valueData)
}
func updateAttributeViewCellInBlock(tx *Transaction, avID, blockID, keyID, itemID string,
valueData any) (val *av.Value, err error) {
attrView, err := avParseView(avID, blockID)
if err != nil {
return
}
val, err = updateAttributeViewValue(tx, attrView, keyID, itemID, valueData, false, blockID)
if nil != err {
return
}
regenAttrViewGroups(attrView)
if err = avSaveView(attrView, blockID); nil != err {
return
}
refreshRelatedSrcAvsInBlock(attrView.ID, blockID, tx)
return
}
func updateAttributeViewValue(tx *Transaction, attrView *av.AttributeView, keyID, itemID string, valueData any,
save bool, blockIDs ...string) (val *av.Value, err error) {
return updateAttributeViewValue0(tx, attrView, keyID, itemID, valueData, save, nil, blockIDs...)
}
type attrViewValueUpdateContext struct {
keyValues map[string]*av.KeyValues
blockValues map[string]*av.Value
values map[string]map[string]*av.Value
availableAVColors []int
}
func newAttrViewValueUpdateContext(attrView *av.AttributeView) *attrViewValueUpdateContext {
context := &attrViewValueUpdateContext{
keyValues: map[string]*av.KeyValues{},
blockValues: map[string]*av.Value{},
values: map[string]map[string]*av.Value{},
}
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
context.keyValues[keyValues.Key.ID] = keyValues
values := map[string]*av.Value{}
for _, value := range keyValues.Values {
if nil == value {
continue
}
if _, exists := values[value.BlockID]; !exists {
values[value.BlockID] = value
}
if av.KeyTypeBlock == keyValues.Key.Type {
if _, exists := context.blockValues[value.BlockID]; !exists {
context.blockValues[value.BlockID] = value
}
}
}
context.values[keyValues.Key.ID] = values
}
return context
}
func updateAttributeViewValue0(tx *Transaction, attrView *av.AttributeView, keyID, itemID string, valueData any,
save bool, context *attrViewValueUpdateContext, blockIDs ...string) (val *av.Value, err error) {
avID := attrView.ID
blockID := ""
if 0 < len(blockIDs) {
blockID = blockIDs[0]
}
if err = tx.rememberAutomationView(attrView, blockID); err != nil {
return
}
var keyValues *av.KeyValues
var blockVal *av.Value
if nil == context {
keyValues, err = attrView.GetKeyValues(keyID)
if nil != err {
return
}
blockVal = attrView.GetBlockValue(itemID)
} else {
keyValues = context.keyValues[keyID]
if nil == keyValues {
err = av.ErrKeyNotFound
return
}
blockVal = context.blockValues[itemID]
}
if nil == blockVal {
err = av.ErrItemNotFound
return
}
now := time.Now().UnixMilli()
oldIsDetached := blockVal.IsDetached
oldBoundBlockID := blockVal.Block.ID
oldCollectionRuleID := blockVal.Block.CollectionRuleID
if nil == context {
for _, value := range keyValues.Values {
if itemID == value.BlockID {
val = value
break
}
}
} else {
val = context.values[keyID][itemID]
}
if nil != val && av.KeyTypeLocation != keyValues.Key.Type {
val.Type = keyValues.Key.Type
}
created := false
if nil == val {
val = &av.Value{ID: ast.NewNodeID(), KeyID: keyID, BlockID: itemID, Type: keyValues.Key.Type, CreatedAt: now, UpdatedAt: now}
created = true
}
valueID := val.ID
valueType := keyValues.Key.Type
valueCreatedAt := val.CreatedAt
oldText := val.Text
isUpdatingBlockKey := av.KeyTypeBlock == val.Type
var oldRelationBlockIDs []string
if av.KeyTypeRelation == val.Type {
if nil != val.Relation {
for _, bID := range val.Relation.BlockIDs {
oldRelationBlockIDs = append(oldRelationBlockIDs, bID)
}
}
}
data, err := gulu.JSON.MarshalJSON(valueData)
if err != nil {
logging.LogErrorf("marshal value [%+v] failed: %s", valueData, err)
return
}
updatedVal := val
// 文本、位置和主键值先在副本上合并和校验,避免校验失败污染原值,并保留部分更新语义。
if av.KeyTypeText == valueType || av.KeyTypeBlock == valueType || av.KeyTypeLocation == valueType {
updatedVal = val.Clone()
if nil == updatedVal {
err = fmt.Errorf("clone attribute view text value [%s] failed", valueID)
return
}
}
if err = gulu.JSON.UnmarshalJSON(data, updatedVal); err != nil {
logging.LogErrorf("unmarshal data [%s] failed: %s", data, err)
return
}
updatedVal.ID = valueID
updatedVal.KeyID = keyID
updatedVal.BlockID = itemID
updatedVal.Type = valueType
updatedVal.CreatedAt = valueCreatedAt
if av.KeyTypeBlock == valueType && updatedVal.Block != nil {
updatedVal.Block.CollectionRuleID = ""
if !updatedVal.IsDetached && !oldIsDetached && updatedVal.Block.ID == oldBoundBlockID {
updatedVal.Block.CollectionRuleID = oldCollectionRuleID
}
}
if av.KeyTypeBlock == valueType && !updatedVal.IsDetached {
if updatedVal.Block == nil {
return nil, ErrBlockNotFound
}
node, tree, loadErr := getNodeByBlockID(tx, updatedVal.Block.ID)
if loadErr != nil {
return nil, loadErr
}
if err = validateAttributeViewBinding(avID, tree); err != nil {
return
}
if oldIsDetached || oldBoundBlockID != updatedVal.Block.ID {
if err = inheritAttributeViewBlockIcon(tx, node, tree, blockVal.Block.Icon); err != nil {
return
}
}
}
if av.KeyTypeText == updatedVal.Type && nil != updatedVal.Text {
if nil != oldText && nil != oldText.Rich && !attributeViewTextRichFieldPresent(data) &&
updatedVal.Text.Content != oldText.Content {
updatedVal.Text.Rich = nil
}
if err = updatedVal.Text.NormalizeRichContent(); nil != err {
return
}
}
if av.KeyTypeLocation == valueType {
if err = updatedVal.Location.Normalize(); nil != err {
return
}
normalizeAttributeViewLocationProvenance(val.Location, updatedVal.Location, data)
}
if updatedVal != val {
*val = *updatedVal
}
if created {
keyValues.Values = append(keyValues.Values, val)
if nil != context {
context.values[keyID][itemID] = val
}
}
key, _ := attrView.GetKey(keyID)
if av.KeyTypeNumber == val.Type {
if nil != val.Number {
if !val.Number.IsNotEmpty {
val.Number.Content = 0
val.Number.FormattedContent = ""
} else {
val.Number.FormatNumber()
}
}
} else if av.KeyTypeDate == val.Type {
if nil != val.Date {
if !val.Date.IsNotEmpty {
val.Date.Content = 0
val.Date.FormattedContent = ""
} else if nil != key {
val.Date.FormatDate(key.DateFormat)
}
}
} else if av.KeyTypeSelect == val.Type || av.KeyTypeMSelect == val.Type {
if nil != key && 0 < len(val.MSelect) {
var tmp []*av.ValueSelect
// 移除空选项 https://github.com/siyuan-note/siyuan/issues/15533
for _, v := range val.MSelect {
if "" != v.Content {
tmp = append(tmp, v)
}
}
val.MSelect = tmp
if 1 > len(val.MSelect) {
return
}
// The selection options are inconsistent after pasting data into the database https://github.com/siyuan-note/siyuan/issues/11409
var availableColors []int
for _, valOpt := range val.MSelect {
if opt := key.GetOption(valOpt.Content); nil == opt {
// 不存在的选项新建保存
color := attrView.FilterColorValue(valOpt.Color)
if "" == color {
if nil == availableColors {
if nil != context {
if nil == context.availableAVColors {
context.availableAVColors = getVisibleAVBuiltinColorIndexes()
}
availableColors = context.availableAVColors
} else {
availableColors = getVisibleAVBuiltinColorIndexes()
}
}
color = fmt.Sprintf("%d", availableColors[rand.Intn(len(availableColors))])
}
opt = &av.SelectOption{Name: valOpt.Content, Color: color}
key.Options = append(key.Options, opt)
} else {
// 已经存在的选项颜色需要保持不变
valOpt.Color = opt.Color
}
}
}
}
relationChangeMode := 0 // 0:不变(仅排序),1:增加,2:减少
if av.KeyTypeRelation == val.Type {
// 关联字段得 content 是自动渲染的,所以不需要保存
val.Relation.Contents = nil
val.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(val.Relation.BlockIDs)
// 计算关联变更模式
if !slices.Equal(oldRelationBlockIDs, val.Relation.BlockIDs) {
if len(oldRelationBlockIDs) > len(val.Relation.BlockIDs) {
relationChangeMode = 2
} else {
relationChangeMode = 1
}
}
}
// val.IsDetached 只有更新主键的时候才会传入,所以下面需要结合 isUpdatingBlockKey 来判断
if isUpdatingBlockKey {
if oldIsDetached {
// 之前是非绑定块
if !val.IsDetached { // 现在绑定了块
bindBlockAv(tx, avID, val.Block.ID)
node, _, _ := getNodeByBlockID(tx, val.Block.ID)
if nil != node {
icon, content := getNodeAvBlockText(node, avID)
val.Block.Icon = icon
val.Block.Content = util.UnescapeHTML(content)
val.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
} else {
val.Block.RefSubtype = av.BlockRefSubtypeDynamic
}
} else {
val.Block.RefSubtype = ""
}
} else {
// 之前绑定了块
if val.IsDetached { // 现在是非绑定块
unbindBlockAv(tx, avID, val.Block.ID)
val.Block.ID = ""
val.Block.RefSubtype = ""
} else {
// 现在也绑定了块
if oldBoundBlockID != val.Block.ID { // 之前绑定的块和现在绑定的块不一样
// 换绑块
unbindBlockAv(tx, avID, oldBoundBlockID)
bindBlockAv(tx, avID, val.Block.ID)
node, _, _ := getNodeByBlockID(tx, val.Block.ID)
if nil != node {
icon, content := getNodeAvBlockText(node, avID)
val.Block.Icon = icon
val.Block.Content = util.UnescapeHTML(content)
val.Block.RefSubtype = getNodeAvBlockRefSubtype(node, avID)
} else {
val.Block.Content = util.UnescapeHTML(val.Block.Content)
val.Block.RefSubtype = av.BlockRefSubtypeDynamic
}
} else { // 之前绑定的块和现在绑定的块一样
content := strings.TrimSpace(val.Block.Content)
node, tree, _ := getNodeByBlockID(tx, val.Block.ID)
_, blockText := getNodeAvBlockText(node, "")
if "" == content {
// 使用动态锚文本
val.Block.Content = util.UnescapeHTML(blockText)
val.Block.RefSubtype = av.BlockRefSubtypeDynamic
updateBlockValueStaticText(tx, node, tree, avID, "")
} else {
val.Block.Content = content
val.Block.RefSubtype = av.BlockRefSubtypeStatic
updateBlockValueStaticText(tx, node, tree, avID, content)
}
}
}
}
}
blockVal.Block.Updated = now
blockVal.SetUpdatedAt(now)
if isUpdatingBlockKey {
blockVal.IsDetached = val.IsDetached
}
val.SetUpdatedAt(now)
if nil != key && av.KeyTypeRelation == key.Type && nil != key.Relation && key.Relation.IsTwoWay {
// 双向关联需要同时更新目标字段的值
if err = updateTwoWayRelationDestAttrViewInBlock(attrView, key, val, relationChangeMode,
oldRelationBlockIDs, blockID); nil != err {
return
}
}
if save {
regenAttrViewGroups(attrView)
if err = avSaveView(attrView, blockID); nil != err {
return
}
}
if 0 != relationChangeMode && nil != key && nil != key.Relation && "" != key.Relation.AvID && key.Relation.AvID != avID {
ReloadAttrView(key.Relation.AvID)
}
if save {
refreshRelatedSrcAvsInBlock(avID, blockID, tx)
}
return
}
func attributeViewTextRichFieldPresent(data []byte) bool {
var valueFields map[string]json.RawMessage
if err := json.Unmarshal(data, &valueFields); nil != err {
return false
}
textData, ok := valueFields["text"]
if !ok {
return false
}
var textFields map[string]json.RawMessage
if err := json.Unmarshal(textData, &textFields); nil != err {
return false
}
_, ret := textFields["rich"]
return ret
}
func refreshRelatedSrcAvs(destAvID string, tx *Transaction) {
refreshRelatedSrcAvsInBlock(destAvID, "", tx)
}
func refreshRelatedSrcAvsInBlock(destAvID, blockID string, tx *Transaction) {
relatedAvIDs := av.GetSrcAvIDsForRefresh([]string{destAvID})
if nil != tx {
tx.relatedAvIDs = append(tx.relatedAvIDs, relatedAvIDs...)
} else {
for _, relatedAvID := range relatedAvIDs {
destAv, _ := avParseView(relatedAvID, blockID)
if nil == destAv {
continue
}
regenAttrViewGroups(destAv)
avSaveView(destAv, blockID)
ReloadAttrView(relatedAvID)
}
}
}
// relationChangeMode
// 0:关联字段值不变(仅排序),不影响目标值
// 1:关联字段值增加,增加目标值
// 2:关联字段值减少,减少目标值
func updateTwoWayRelationDestAttrView(attrView *av.AttributeView, relKey *av.Key, val *av.Value, relationChangeMode int, oldRelationBlockIDs []string) {
_ = updateTwoWayRelationDestAttrViewInBlock(attrView, relKey, val, relationChangeMode, oldRelationBlockIDs, "")
}
func updateTwoWayRelationDestAttrViewInBlock(attrView *av.AttributeView, relKey *av.Key, val *av.Value,
relationChangeMode int, oldRelationBlockIDs []string, blockID string) (err error) {
var destAv *av.AttributeView
if attrView.ID == relKey.Relation.AvID {
destAv = attrView
} else {
destAv, _ = avParseView(relKey.Relation.AvID, blockID)
}
// 目标数据库已删除或损坏时无法清理反向值,但不能因此阻止源条目删除。
if nil == destAv {
return
}
now := util.CurrentTimeMillis()
if 0 != relationChangeMode {
addBlockIDs := val.Relation.BlockIDs
for _, bID := range oldRelationBlockIDs {
addBlockIDs = gulu.Str.RemoveElem(addBlockIDs, bID)
}
for _, blockID := range addBlockIDs {
for _, keyValues := range destAv.KeyValues {
if keyValues.Key.ID != relKey.Relation.BackKeyID {
continue
}
destVal := keyValues.GetValue(blockID)
if nil == destVal {
destVal = &av.Value{ID: ast.NewNodeID(), KeyID: keyValues.Key.ID, BlockID: blockID, Type: keyValues.Key.Type, Relation: &av.ValueRelation{}, CreatedAt: now, UpdatedAt: now + 1000}
keyValues.Values = append(keyValues.Values, destVal)
}
destVal.Relation.BlockIDs = append(destVal.Relation.BlockIDs, val.BlockID)
destVal.Relation.BlockIDs = gulu.Str.RemoveDuplicatedElem(destVal.Relation.BlockIDs)
break
}
}
}
if 0 != relationChangeMode {
removeBlockIDs := oldRelationBlockIDs
for _, bID := range val.Relation.BlockIDs {
removeBlockIDs = gulu.Str.RemoveElem(removeBlockIDs, bID)
}
for _, blockID := range removeBlockIDs {
for _, keyValues := range destAv.KeyValues {
if keyValues.Key.ID != relKey.Relation.BackKeyID {
continue
}
for _, value := range keyValues.Values {
if value.BlockID == blockID {
value.Relation.BlockIDs = gulu.Str.RemoveElem(value.Relation.BlockIDs, val.BlockID)
value.SetUpdatedAt(now)
break
}
}
}
}
}
if destAv != attrView {
regenAttrViewGroups(destAv)
err = avSaveView(destAv, blockID)
}
return
}
// regenAttrViewGroups 重新生成分组视图。
func regenAttrViewGroups(attrView *av.AttributeView) {
for _, view := range attrView.Views {
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
continue
}
genAttrViewGroups(view, attrView)
}
}
func unbindBlockAv(tx *Transaction, avID, nodeID string) {
node, tree, err := getNodeByBlockID(tx, nodeID)
if err != nil {
return
}
attrs := parse.IAL2Map(node.KramdownIAL)
if "" == attrs[av.NodeAttrNameAvs] {
return
}
avIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
avIDs = gulu.Str.RemoveElem(avIDs, avID)
if 0 == len(avIDs) {
attrs[av.NodeAttrNameAvs] = ""
} else {
attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
}
avNames := getAvNames(attrs[av.NodeAttrNameAvs])
if "" != avNames {
attrs[av.NodeAttrViewNames] = avNames
}
if nil != tx {
err = setNodeAttrsWithTx(tx, node, tree, attrs)
} else {
err = setNodeAttrs(node, tree, attrs)
}
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", nodeID, err)
return
}
}
func (tx *Transaction) doSortAttrViewBinding(operation *Operation) (ret *TxErr) {
tree, err := tx.loadTree(operation.ID)
if err != nil {
logging.LogErrorf("load tree [%s] failed: %s", operation.ID, err)
return &TxErr{code: TxErrCodeBlockNotFound, id: operation.ID}
}
node := treenode.GetNodeInTree(tree, operation.ID)
if nil == node {
logging.LogErrorf("get node [%s] in tree [%s] failed", operation.ID, tree.Root.ID)
return &TxErr{code: TxErrCodeBlockNotFound, id: operation.ID}
}
attrs := parse.IAL2Map(node.KramdownIAL)
avIDs, err := sortAttrViewBindingIDs(strings.Split(attrs[av.NodeAttrNameAvs], ","), operation.AvID, operation.PreviousID)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
avs := strings.Join(avIDs, ",")
if err = setNodeAttrsWithTx(tx, node, tree, map[string]string{
av.NodeAttrNameAvs: avs,
av.NodeAttrViewNames: getAvNames(avs),
}); err != nil {
logging.LogErrorf("sort attribute view binding [%s] failed: %s", operation.AvID, err)
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func sortAttrViewBindingIDs(avIDs []string, avID, previousAvID string) (ret []string, err error) {
ret = append([]string(nil), avIDs...)
if avID == previousAvID {
return
}
index := -1
for i, id := range ret {
if id == avID {
index = i
break
}
}
if 0 > index {
return nil, fmt.Errorf("attribute view [%s] is not bound", avID)
}
ret = append(ret[:index], ret[index+1:]...)
previousIndex := -1
if "" != previousAvID {
for i, id := range ret {
if id == previousAvID {
previousIndex = i
break
}
}
if 0 > previousIndex {
return nil, fmt.Errorf("previous attribute view [%s] is not bound", previousAvID)
}
}
ret = slices.Insert(ret, previousIndex+1, avID)
return
}
func bindBlockAv(tx *Transaction, avID, blockID string) {
node, tree, err := getNodeByBlockID(tx, blockID)
if err != nil {
return
}
bindBlockAv0(tx, avID, node, tree)
}
func bindBlockAv0(tx *Transaction, avID string, node *ast.Node, tree *parse.Tree) {
if err := validateAttributeViewBinding(avID, tree); err != nil {
return
}
attrs := parse.IAL2Map(node.KramdownIAL)
if "" == attrs[av.NodeAttrNameAvs] {
attrs[av.NodeAttrNameAvs] = avID
} else {
avIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
avIDs = append(avIDs, avID)
avIDs = gulu.Str.RemoveDuplicatedElem(avIDs)
attrs[av.NodeAttrNameAvs] = strings.Join(avIDs, ",")
}
avNames := getAvNames(attrs[av.NodeAttrNameAvs])
if "" != avNames {
attrs[av.NodeAttrViewNames] = avNames
}
var err error
if nil != tx {
err = setNodeAttrsWithTx(tx, node, tree, attrs)
} else {
err = setNodeAttrs(node, tree, attrs)
}
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", node.ID, err)
return
}
}
func updateBlockValueStaticText(tx *Transaction, node *ast.Node, tree *parse.Tree, avID, text string) {
// 设置静态锚文本 Database-bound block primary key supports setting static anchor text https://github.com/siyuan-note/siyuan/issues/10049
if nil == node {
return
}
attrs := parse.IAL2Map(node.KramdownIAL)
attrs[av.NodeAttrViewStaticText+"-"+avID] = text
var err error
if nil != tx {
err = setNodeAttrsWithTx(tx, node, tree, attrs)
} else {
err = setNodeAttrs(node, tree, attrs)
}
if err != nil {
logging.LogWarnf("set node [%s] attrs failed: %s", node.ID, err)
return
}
}
func getNodeByBlockID(tx *Transaction, blockID string) (node *ast.Node, tree *parse.Tree, err error) {
if nil != tx {
tree, err = tx.loadTree(blockID)
} else {
tree, err = LoadTreeByBlockID(blockID)
}
if err != nil {
return
}
node = treenode.GetNodeInTree(tree, blockID)
if nil == node {
logging.LogWarnf("node [%s] not found in tree [%s]", blockID, tree.ID)
return
}
return
}
func (tx *Transaction) doUpdateAttrViewColOptions(operation *Operation) (ret *TxErr) {
if operation.attributeViewFields != nil {
if err := tx.replayAttributeViewFields(operation); err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return nil
}
err := updateAttributeViewColumnOptions(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func updateAttributeViewColumnOptions(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
jsonData, err := gulu.JSON.MarshalJSON(operation.Data)
if err != nil {
return
}
options := []*av.SelectOption{}
if err = gulu.JSON.UnmarshalJSON(jsonData, &options); err != nil {
return
}
// 移除空选项 https://github.com/siyuan-note/siyuan/issues/15533
var tmp []*av.SelectOption
for _, opt := range options {
if "" != opt.Name {
tmp = append(tmp, opt)
}
}
options = tmp
if 1 > len(options) {
return
}
optionSorts := map[string]int{}
for i, opt := range options {
optionSorts[opt.Name] = i
}
selectKey, _ := attrView.GetKey(operation.ID)
if nil == selectKey {
return
}
existingOptions := map[string]*av.SelectOption{}
for _, opt := range selectKey.Options {
existingOptions[opt.Name] = opt
}
colorChanges := map[string]string{}
for _, opt := range options {
if existingOpt, exists := existingOptions[opt.Name]; exists {
// 如果选项已经存在则更新颜色和描述
newColor := attrView.FilterColorValue(opt.Color)
if existingOpt.Color != newColor {
colorChanges[existingOpt.Name] = newColor
}
existingOpt.Color = newColor
existingOpt.Desc = opt.Desc
} else {
// 如果选项不存在则添加新选项
selectKey.Options = append(selectKey.Options, &av.SelectOption{
Name: opt.Name,
Color: attrView.FilterColorValue(opt.Color),
Desc: opt.Desc,
})
}
}
sortAttributeViewColumnOptions(selectKey.Options, optionSorts)
for name, color := range colorChanges {
syncAttributeViewOptionColor(attrView, selectKey.ID, name, color)
}
regenAttrViewGroups(attrView)
if err = av.SaveAttributeView(attrView); nil != err {
return
}
if 0 == len(colorChanges) {
return
}
for _, relatedAvID := range av.GetSrcAvIDs(attrView.ID) {
if relatedAvID == attrView.ID {
continue
}
relatedAttrView, parseErr := av.ParseAttributeView(relatedAvID)
if nil != parseErr || nil == relatedAttrView {
continue
}
changed := false
for name, color := range colorChanges {
changed = renameAttrViewOptionInFieldFilters(relatedAttrView, attrView.ID, selectKey.ID,
name, name, color) || changed
}
if !changed {
continue
}
if err = av.SaveAttributeView(relatedAttrView); nil != err {
return
}
ReloadAttrView(relatedAvID)
}
return
}
func syncAttributeViewOptionColor(attrView *av.AttributeView, keyID, name, color string) {
attrView.RenameNewItemTemplateSelectOption(keyID, name, name, color)
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key || keyID != keyValues.Key.ID {
continue
}
for _, value := range keyValues.Values {
if nil == value {
continue
}
for _, selection := range value.MSelect {
if nil != selection && name == selection.Content {
selection.Color = color
}
}
}
break
}
for _, view := range attrView.Views {
av.RenameSelectOptionInFilters(view.Filters, keyID, name, name, color)
for _, rule := range view.ConditionalColors {
if nil != rule {
av.RenameSelectOptionInFilters([]*av.ViewFilter{rule.Filter}, keyID, name, name, color)
}
}
}
renameAttrViewOptionInFieldFilters(attrView, attrView.ID, keyID, name, name, color)
}
func sortAttributeViewColumnOptions(options []*av.SelectOption, optionSorts map[string]int) {
var sortableOptions []*av.SelectOption
for _, opt := range options {
if _, ok := optionSorts[opt.Name]; ok {
sortableOptions = append(sortableOptions, opt)
}
}
sort.SliceStable(sortableOptions, func(i, j int) bool {
return optionSorts[sortableOptions[i].Name] < optionSorts[sortableOptions[j].Name]
})
// 仅重排请求中包含的选项,避免过期请求扰动其他请求新增的选项。
sortableIndex := 0
for i, opt := range options {
if _, ok := optionSorts[opt.Name]; ok {
options[i] = sortableOptions[sortableIndex]
sortableIndex++
}
}
}
func (tx *Transaction) doSetAttrViewCustomColors(operation *Operation) (ret *TxErr) {
if err := setAttrViewCustomColors(operation); nil != err {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func parseAttrViewCustomColorsData(data []byte) (colors []*av.AttributeViewCustomColor, order []string, err error) {
trimmed := bytes.TrimSpace(data)
if len(trimmed) > 0 && trimmed[0] == '{' {
decoded := struct {
Colors []*av.AttributeViewCustomColor `json:"colors"`
Order []string `json:"order"`
}{}
if err = gulu.JSON.UnmarshalJSON(data, &decoded); nil != err {
return
}
return decoded.Colors, decoded.Order, nil
}
colors = []*av.AttributeViewCustomColor{}
err = gulu.JSON.UnmarshalJSON(data, &colors)
return
}
func setAttrViewCustomColors(operation *Operation) (err error) {
attrView, err := avParseView(operation.AvID, operation.BlockID)
if nil != err {
return
}
if nil == operation.Data {
return errors.New("attribute view custom colors must not be empty")
}
data, err := gulu.JSON.MarshalJSON(operation.Data)
if nil != err {
return
}
colors, order, err := parseAttrViewCustomColorsData(data)
if nil != err {
return
}
colors, err = av.NormalizeAttributeViewCustomColors(colors, true)
if nil != err {
return
}
oldColors := []*av.AttributeViewCustomColor{}
oldOrder := []string{}
if styles, stylesErr := GetInlineStyles(); nil == stylesErr && styles != nil && styles.AV != nil {
oldColors = styles.AV.Colors
oldOrder = styles.AV.Order
}
if nil == order {
order = oldOrder
}
retainedIndexes := map[int]struct{}{}
for _, color := range colors {
retainedIndexes[color.Index] = struct{}{}
}
usedIndexes := map[int]struct{}{}
for _, index := range attrView.UsedCustomColorIndexes() {
usedIndexes[index] = struct{}{}
}
for _, oldColor := range oldColors {
if nil == oldColor {
continue
}
if _, retained := retainedIndexes[oldColor.Index]; !retained {
if _, used := usedIndexes[oldColor.Index]; used {
return fmt.Errorf("attribute view custom color [%d] is still in use", oldColor.Index)
}
}
}
if err = replaceWorkspaceAVPalette(colors, order); nil != err {
return
}
ReloadAttrView(attrView.ID)
for _, relatedAvID := range av.GetSrcAvIDs(attrView.ID) {
if relatedAvID != attrView.ID {
ReloadAttrView(relatedAvID)
}
}
return
}
func (tx *Transaction) doRemoveAttrViewColOption(operation *Operation) (ret *TxErr) {
err := tx.mutateAttributeViewOption(operation, true)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doUpdateAttrViewColOption(operation *Operation) (ret *TxErr) {
err := tx.mutateAttributeViewOption(operation, false)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func (tx *Transaction) doSetAttrViewColOptionDesc(operation *Operation) (ret *TxErr) {
err := setAttributeViewColumnOptionDesc(operation)
if err != nil {
return &TxErr{code: TxErrHandleAttributeView, id: operation.AvID, msg: err.Error()}
}
return
}
func setAttributeViewColumnOptionDesc(operation *Operation) (err error) {
attrView, err := av.ParseAttributeView(operation.AvID)
if err != nil {
return
}
key, err := attrView.GetKey(operation.ID)
if err != nil {
return
}
data := operation.Data.(map[string]any)
name := data["name"].(string)
desc := data["desc"].(string)
for i, opt := range key.Options {
if name == opt.Name {
key.Options[i].Desc = desc
break
}
}
err = av.SaveAttributeView(attrView)
return
}
func resolveAttributeViewView(attrView *av.AttributeView, viewID, carrierViewID, blockID string) (ret *av.View, err error) {
if "" != viewID {
ret = attrView.GetView(viewID)
if nil == ret {
return nil, av.ErrViewNotFound
}
return
}
if "" != carrierViewID {
if ret = attrView.GetView(carrierViewID); nil != ret {
return
}
}
if "" != blockID {
node, _, _ := getNodeByBlockID(nil, blockID)
if nil != node && ast.NodeAttributeView == node.Type && attrView.ID == node.AttributeViewID {
if ret = attrView.GetView(node.IALAttr(av.NodeAttrView)); nil != ret {
return
}
}
}
return attrView.GetFirstView()
}
func getAttrViewViewByBlockID(attrView *av.AttributeView, blockID string) (ret *av.View, err error) {
return resolveAttributeViewView(attrView, "", "", blockID)
}
func getAttrViewName(attrView *av.AttributeView) string {
ret := strings.TrimSpace(attrView.Name)
if "" == ret {
ret = Conf.language(105)
}
return ret
}
func updateBoundBlockAvsAttribute(avIDs []string, boxID string) {
// 更新指定 avIDs 中绑定块的 avs 属性
cachedTrees, saveTrees := map[string]*parse.Tree{}, map[string]*parse.Tree{}
luteEngine := util.NewLute()
for _, avID := range avIDs {
attrView, _ := av.ParseAttributeViewInBox(avID, boxID)
if nil == attrView {
continue
}
blockKeyValues := attrView.GetBlockKeyValues()
if nil == blockKeyValues || nil == blockKeyValues.Values {
continue
}
for _, blockValue := range blockKeyValues.Values {
if nil == blockValue || blockValue.IsDetached || nil == blockValue.Block {
continue
}
boundBlockID := blockValue.Block.ID
if "" == boundBlockID {
continue
}
bt := attributeViewBindingBlockTree(boundBlockID, boxID)
if nil == bt {
continue
}
tree := cachedTrees[bt.RootID]
if nil == tree {
tree, _ = filesys.LoadTree(bt.BoxID, bt.Path, luteEngine)
if nil == tree {
continue
}
cachedTrees[bt.RootID] = tree
}
node := treenode.GetNodeInTree(tree, boundBlockID)
if nil == node {
continue
}
attrs := parse.IAL2Map(node.KramdownIAL)
if "" == attrs[av.NodeAttrNameAvs] {
attrs[av.NodeAttrNameAvs] = avID
} else {
nodeAvIDs := strings.Split(attrs[av.NodeAttrNameAvs], ",")
nodeAvIDs = append(nodeAvIDs, avID)
nodeAvIDs = gulu.Str.RemoveDuplicatedElem(nodeAvIDs)
attrs[av.NodeAttrNameAvs] = strings.Join(nodeAvIDs, ",")
saveTrees[bt.RootID] = tree
}
avNames := getAvNames(attrs[av.NodeAttrNameAvs])
if "" != avNames {
attrs[av.NodeAttrViewNames] = avNames
}
oldAttrs, setErr := setNodeAttrs0(node, attrs, bt.BoxID)
if nil != setErr {
continue
}
cache.PutBlockIALInBox(node.ID, bt.BoxID, parse.IAL2Map(node.KramdownIAL))
pushBlockAttrs(oldAttrs, node)
if "" != avNames {
node.RemoveIALAttr(av.NodeAttrViewNames)
}
}
}
for _, saveTree := range saveTrees {
if treeErr := indexWriteTreeUpsertQueue(saveTree); nil != treeErr {
logging.LogErrorf("index write tree upsert queue failed: %s", treeErr)
}
avNodes := saveTree.Root.ChildrenByType(ast.NodeAttributeView)
av.BatchUpsertBlockRel(avNodes)
}
}