Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

48.1 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

// Package av 包含了属性视图(Attribute View)相关的实现。
package av

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"slices"
	"sort"
	"strconv"
	"strings"

	"github.com/88250/gulu"
	"github.com/88250/lute/ast"
	"github.com/goccy/go-json"
	jsoniter "github.com/json-iterator/go"
	"github.com/siyuan-note/filelock"
	"github.com/siyuan-note/logging"
	"github.com/siyuan-note/siyuan/kernel/cache"
	"github.com/siyuan-note/siyuan/kernel/util"
	"golang.org/x/sync/singleflight"
)

// AttributeView 描述了属性视图的结构。
type AttributeView struct {
	Spec              int                `json:"spec"`                        // 格式版本
	ID                string             `json:"id"`                          // 属性视图 ID
	Name              string             `json:"name"`                        // 属性视图名称
	KeyValues         []*KeyValues       `json:"keyValues"`                   // 属性视图属性键值
	KeyIDs            []string           `json:"keyIDs"`                      // 属性视图属性键 ID,用于排序
	Views             []*View            `json:"views"`                       // 视图
	NewItemTemplates  []*NewItemTemplate `json:"newItemTemplates,omitempty"`  // 新增条目模板
	DefaultTemplateID string             `json:"defaultTemplateID,omitempty"` // 默认新增条目模板 ID
	Automations       *AutomationConfig  `json:"automations,omitempty"`
	// CustomColorRenderContext 保存只读渲染期间的关联数据库调色板上下文。
	CustomColorRenderContext *CustomColorRenderContext `json:"-"`
	// 卡片封面位置,条目 ID -> 封面来源 -> 位置
	CardCoverPositions map[string]map[string]*CardCoverPosition `json:"cardCoverPositions,omitempty"`

	RenderedViewables map[string]Viewable `json:"-"` // 已经渲染好的视图

	cardCoverPositionsChanged bool
	sourceVersion             uint64
	sourceGeneration          uint64
	liveOrdinarySource        bool
}

// RenderSourceVersion 只标识当前工作区普通数据库的已认证源版本,临时副本不参与跨请求复用。
func (attrView *AttributeView) RenderSourceVersion() (version, generation uint64) {
	if attrView != nil && attrView.liveOrdinarySource {
		return attrView.sourceVersion, attrView.sourceGeneration
	}
	return 0, 0
}

// CustomColorRenderContext 为历史和仓库快照渲染解析关联数据库当时的调色板。
type CustomColorRenderContext struct {
	ResolveRelatedCustomColors func(avID string) (colors []*AttributeViewCustomColor, order []string, found bool)
}

// NewItemTargetType 描述新增条目模板创建的目标类型。
type NewItemTargetType string

const (
	NewItemTargetDetached NewItemTargetType = "detached"
	NewItemTargetDocument NewItemTargetType = "document"
)

// NewItemSaveLocation 描述文档类型模板覆盖全局新建文档位置后的保存位置。
// nil 表示继承全局配置,非 nil 且 BoxID 为空表示使用当前数据库实例所在笔记本。
type NewItemSaveLocation struct {
	BoxID        string `json:"boxID,omitempty"`
	PathTemplate string `json:"pathTemplate"`
}

// NewItemFieldValueMode 描述新增条目模板字段默认值的填充方式。
type NewItemFieldValueMode string

const (
	NewItemFieldValueStatic      NewItemFieldValueMode = "static"
	NewItemFieldValueCurrentTime NewItemFieldValueMode = "currentTime"
)

// NewItemFieldValue 描述新增条目模板中的一个字段默认值。
type NewItemFieldValue struct {
	Mode  NewItemFieldValueMode `json:"mode"`
	Value *Value                `json:"value,omitempty"`
}

// NewItemTemplate 描述数据库新增条目时使用的模板。
type NewItemTemplate struct {
	ID                  string                        `json:"id"`
	Name                string                        `json:"name"`
	Icon                string                        `json:"icon,omitempty"`
	TargetType          NewItemTargetType             `json:"targetType"`
	PrimaryKeyTemplate  string                        `json:"primaryKeyTemplate,omitempty"`
	FieldValues         map[string]*NewItemFieldValue `json:"fieldValues,omitempty"`
	SaveLocation        *NewItemSaveLocation          `json:"saveLocation,omitempty"`
	ContentTemplatePath string                        `json:"contentTemplatePath,omitempty"`
	HideInFileTree      bool                          `json:"hideInFileTree,omitempty"`
	// nil 保留旧客户端行为;false 不自动打开,true 创建后由交互客户端分屏打开。
	OpenAfterCreate *bool `json:"openAfterCreate,omitempty"`
}

// NewItemTemplatesConfig 描述一次完整的新增条目模板配置修改。
type NewItemTemplatesConfig struct {
	Templates         []*NewItemTemplate `json:"templates"`
	DefaultTemplateID string             `json:"defaultTemplateID,omitempty"`
}

// KeyValues 描述了属性视图属性键值列表的结构。
type KeyValues struct {
	Key    *Key     `json:"key"`              // 属性视图属性键
	Values []*Value `json:"values,omitempty"` // 属性视图属性值列表
}

func (kValues *KeyValues) GetValue(blockID string) (ret *Value) {
	for _, v := range kValues.Values {
		if v.BlockID == blockID {
			ret = v
			return
		}
	}
	return
}

func (kValues *KeyValues) GetBlockValue() (ret *Value) {
	for _, v := range kValues.Values {
		if KeyTypeBlock == v.Type {
			ret = v
			return
		}
	}
	return
}

func GetValue(keyValues []*KeyValues, keyID, itemID string) (ret *Value) {
	for _, kv := range keyValues {
		if kv.Key.ID == keyID {
			for _, v := range kv.Values {
				if v.BlockID == itemID {
					ret = v
					return
				}
			}
		}
	}
	return
}

// KeyType 描述了属性视图属性字段的类型。
type KeyType string

const (
	KeyTypeBlock      KeyType = "block"      // 主键
	KeyTypeText       KeyType = "text"       // 文本
	KeyTypeNumber     KeyType = "number"     // 数字
	KeyTypeDate       KeyType = "date"       // 日期
	KeyTypeSelect     KeyType = "select"     // 单选
	KeyTypeMSelect    KeyType = "mSelect"    // 多选
	KeyTypeURL        KeyType = "url"        // URL
	KeyTypeEmail      KeyType = "email"      // Email
	KeyTypePhone      KeyType = "phone"      // 电话
	KeyTypeLocation   KeyType = "location"   // 位置
	KeyTypeMAsset     KeyType = "mAsset"     // 资源
	KeyTypeTemplate   KeyType = "template"   // 模板
	KeyTypeCreated    KeyType = "created"    // 创建时间
	KeyTypeUpdated    KeyType = "updated"    // 更新时间
	KeyTypeCheckbox   KeyType = "checkbox"   // 复选框
	KeyTypeRelation   KeyType = "relation"   // 关联
	KeyTypeRollup     KeyType = "rollup"     // 汇总
	KeyTypeLineNumber KeyType = "lineNumber" // 行号
)

// Key 描述了属性视图属性字段的基础结构。
type Key struct {
	ID                       string  `json:"id"`                                 // 字段 ID
	Name                     string  `json:"name"`                               // 字段名
	Type                     KeyType `json:"type"`                               // 字段类型
	Icon                     string  `json:"icon"`                               // 字段图标
	Desc                     string  `json:"desc"`                               // 字段描述
	AttributePanelVisibility string  `json:"attributePanelVisibility,omitempty"` // 属性面板可见性,空值沿用全局设置

	// 以下是某些列类型的特有属性

	// 单选/多选
	Options []*SelectOption `json:"options,omitempty"` // 选项列表

	// 数字
	NumberFormat NumberFormat `json:"numberFormat"` // 列数字格式化

	// 日期、创建时间、更新时间
	DateFormat DateDisplayFormat `json:"dateFormat,omitempty"` // 日期显示格式

	// 模板
	Template string `json:"template"` // 模板内容

	// 显示模板
	RenderTemplate string `json:"renderTemplate,omitempty"` // 显示模板内容

	// 关联
	Relation *Relation `json:"relation,omitempty"` // 关联信息

	// 汇总
	Rollup *Rollup `json:"rollup,omitempty"` // 汇总信息

	// 日期
	Date *Date `json:"date,omitempty"` // 日期设置

	// 创建时间
	Created *Created `json:"created,omitempty"` // 创建时间设置

	// 更新时间
	Updated *Updated `json:"updated,omitempty"` // 更新时间设置
}

func NewKey(id, name, icon string, keyType KeyType) *Key {
	return &Key{
		ID:   id,
		Name: name,
		Type: keyType,
		Icon: icon,
	}
}

func (k *Key) GetOption(name string) (ret *SelectOption) {
	for _, option := range k.Options {
		if option.Name == name {
			ret = option
			return
		}
	}
	return
}

type Created struct {
	IncludeTime bool `json:"includeTime"` // 是否填充具体时间 Add `Include time` switch to database creation time field and update time field https://github.com/siyuan-note/siyuan/issues/12091
}

type Updated struct {
	IncludeTime bool `json:"includeTime"` // 是否填充具体时间 Add `Include time` switch to database creation time field and update time field https://github.com/siyuan-note/siyuan/issues/12091
}

type Date struct {
	AutoFillNow      bool `json:"autoFillNow"`      // 是否自动填充当前时间 The database date field supports filling the current time by default https://github.com/siyuan-note/siyuan/issues/10823
	FillSpecificTime bool `json:"fillSpecificTime"` // 是否填充具体时间 Add `Default fill specific time` switch to database date field https://github.com/siyuan-note/siyuan/issues/12089
}

type Rollup struct {
	RelationKeyID string        `json:"relationKeyID"`     // 关联字段 ID
	KeyID         string        `json:"keyID"`             // 目标字段 ID
	Calc          *RollupCalc   `json:"calc"`              // 计算方式
	Filters       []*ViewFilter `json:"filters,omitempty"` // 参与汇总计算的目标条目过滤规则
}

type RollupCalc struct {
	Operator CalcOperator `json:"operator"`
	Result   *Value       `json:"result"`
}

type Relation struct {
	AvID             string        `json:"avID"`                       // 关联的属性视图 ID
	IsTwoWay         bool          `json:"isTwoWay"`                   // 是否双向关联
	BackKeyID        string        `json:"backKeyID"`                  // 双向关联时回链关联列的 ID
	CandidateFilters []*ViewFilter `json:"candidateFilters,omitempty"` // 可关联目标条目的过滤规则
}

type SelectOption struct {
	Name          string              `json:"name"`                    // 选项名称
	Color         string              `json:"color"`                   // 选项颜色
	Desc          string              `json:"desc"`                    // 选项描述
	ResolvedColor *AttributeViewColor `json:"resolvedColor,omitempty"` // 渲染阶段解析后的自定义颜色
}

// FilterColorValue 校验内置选项颜色值,仅允许空字符串或 1-14 的调色板索引,非法值返回空字符串。
func FilterColorValue(color string) string {
	color = strings.TrimSpace(color)
	if "" == color {
		return ""
	}
	n, err := strconv.Atoi(color)
	if nil != err || 1 > n || 14 < n {
		return ""
	}
	return strconv.Itoa(n)
}

// FilterWidthValue 校验列宽度值,仅允许空字符串或合法的 CSS 长度值,非法值返回空字符串,防止注入到样式属性中
func FilterWidthValue(width string) string {
	width = strings.TrimSpace(width)
	if "" == width {
		return ""
	}
	if !widthValuePattern.MatchString(width) {
		return ""
	}
	return width
}

var widthValuePattern = regexp.MustCompile(`^\d+(\.\d+)?(px|em|rem|%)$`)

// View 描述了视图的结构。
type View struct {
	ConditionalColors []*ConditionalColorRule `json:"conditionalColors"` // nil 兼容旧日历,空数组禁用颜色
	ID                string                  `json:"id"`                // 视图 ID
	Icon              string                  `json:"icon"`              // 视图图标
	Name              string                  `json:"name"`              // 视图名称
	HideAttrViewName  bool                    `json:"hideAttrViewName"`  // 是否隐藏属性视图名称
	Desc              string                  `json:"desc"`              // 视图描述
	Filters           []*ViewFilter           `json:"filters,omitempty"` // 过滤规则
	Sorts             []*ViewSort             `json:"sorts,omitempty"`   // 排序规则
	PageSize          int                     `json:"pageSize"`          // 每页条目数
	LayoutType        LayoutType              `json:"type"`              // 当前布局类型
	Table             *LayoutTable            `json:"table,omitempty"`   // 表格布局
	LegacyMap         json.RawMessage         `json:"map,omitempty"`     // 仅保留旧地图配置,不参与渲染或修改
	Calendar          *LayoutCalendar         `json:"calendar,omitempty"`
	List              *LayoutList             `json:"list,omitempty"`    // 列表布局
	Gallery           *LayoutGallery          `json:"gallery,omitempty"` // 卡片布局
	Kanban            *LayoutKanban           `json:"kanban,omitempty"`  // 看板布局
	ItemIDs           []string                `json:"itemIds,omitempty"` // 项目 ID 列表,用于维护所有项目

	Group        *ViewGroup `json:"group,omitempty"`     // 分组规则
	GroupCreated int64      `json:"groupCreated"`        // 分组生成时间戳
	Groups       []*View    `json:"groups,omitempty"`    // 分组视图列表
	GroupItemIDs []string   `json:"groupItemIds"`        // 分组项目 ID 列表,用于维护分组中的所有项目
	GroupCalc    *GroupCalc `json:"groupCalc,omitempty"` // 分组计算规则
	GroupKey     *Key       `json:"groupKey,omitempty"`  // 分组字段
	GroupVal     *Value     `json:"groupVal,omitempty"`  // 分组值
	GroupFolded  bool       `json:"groupFolded"`         // 分组是否折叠
	GroupHidden  int        `json:"groupHidden"`         // 分组是否隐藏,0:显示,1:空白隐藏,2:手动隐藏
	GroupSort    int        `json:"groupSort"`           // 分组排序值,用于手动排序

	legacyMapFallback bool
}

// ViewData 用于序列化视图数据到前端。
type ViewData struct {
	ID               string     `json:"id"`
	Icon             string     `json:"icon"`
	Name             string     `json:"name"`
	Desc             string     `json:"desc"`
	HideAttrViewName bool       `json:"hideAttrViewName"`
	Type             LayoutType `json:"type"`
	PageSize         int        `json:"pageSize"`
}

func (view *View) IsGroupView() bool {
	return LayoutTypeCalendar != view.LayoutType && nil != view.Group && "" != view.Group.Field
}

// GetGroupValue 获取分组视图的分组值。
func (view *View) GetGroupValue() string {
	if nil == view.GroupVal {
		return ""
	}
	return view.GroupVal.String(false)
}

// GetGroupByID 获取指定分组 ID 的分组视图。
func (view *View) GetGroupByID(groupID string) *View {
	if nil == view.Groups {
		return nil
	}
	for _, group := range view.Groups {
		if group.ID == groupID {
			return group
		}
	}
	return nil
}

// GetGroupByGroupValue 获取指定分组值的分组视图。
func (view *View) GetGroupByGroupValue(groupVal string) *View {
	if nil == view.Groups {
		return nil
	}
	for _, group := range view.Groups {
		if group.GetGroupValue() == groupVal {
			return group
		}
	}
	return nil
}

// RemoveGroupByID 从分组视图列表中移除指定 ID 的分组视图。
func (view *View) RemoveGroupByID(groupID string) {
	if nil == view.Groups {
		return
	}
	for i, group := range view.Groups {
		if group.ID == groupID {
			view.Groups = append(view.Groups[:i], view.Groups[i+1:]...)
			return
		}
	}
}

// GetGroupKey 获取分组视图的分组字段。
func (view *View) GetGroupKey(attrView *AttributeView) (ret *Key) {
	if !view.IsGroupView() {
		return
	}

	for _, kv := range attrView.KeyValues {
		if kv.Key.ID == view.Group.Field {
			ret = kv.Key
			return
		}
	}
	return
}

// GroupCalc 描述了分组计算规则和结果的结构。
type GroupCalc struct {
	Field     string     `json:"field"` // 字段 ID
	FieldCalc *FieldCalc `json:"calc"`  // 计算规则和结果
}

// LayoutType 描述了视图布局类型。
type LayoutType string

const (
	LayoutTypeTable    LayoutType = "table" // 属性视图类型 - 表格
	LayoutTypeCalendar LayoutType = "calendar"
	LayoutTypeList     LayoutType = "list"    // 属性视图类型 - 列表
	LayoutTypeGallery  LayoutType = "gallery" // 属性视图类型 - 卡片
	LayoutTypeKanban   LayoutType = "kanban"  // 属性视图类型 - 看板
)

const (
	ViewDefaultPageSize = 50 // 视图默认分页大小
)

func NewTableView() *View {
	return &View{
		ID:         ast.NewNodeID(),
		Name:       GetAttributeViewI18n("table"),
		Filters:    []*ViewFilter{{Combination: FilterCombinationAnd}},
		Sorts:      []*ViewSort{},
		PageSize:   ViewDefaultPageSize,
		LayoutType: LayoutTypeTable,
		Table:      NewLayoutTable(),
	}
}

func NewTableViewWithBlockKey(blockKeyID string) (view *View, blockKey, selectKey *Key) {
	name := GetAttributeViewI18n("table")
	view = &View{
		ID:         ast.NewNodeID(),
		Name:       name,
		Filters:    []*ViewFilter{{Combination: FilterCombinationAnd}},
		Sorts:      []*ViewSort{},
		LayoutType: LayoutTypeTable,
		Table:      NewLayoutTable(),
		PageSize:   ViewDefaultPageSize,
	}
	blockKey = NewKey(blockKeyID, GetAttributeViewI18n("key"), "", KeyTypeBlock)
	view.Table.Columns = []*ViewTableColumn{{BaseField: &BaseField{ID: blockKeyID}}}

	selectKey = NewKey(ast.NewNodeID(), GetAttributeViewI18n("select"), "", KeyTypeSelect)
	view.Table.Columns = append(view.Table.Columns, &ViewTableColumn{BaseField: &BaseField{ID: selectKey.ID}})
	return
}

func NewGalleryView() (ret *View) {
	return &View{
		ID:         ast.NewNodeID(),
		Name:       GetAttributeViewI18n("gallery"),
		Filters:    []*ViewFilter{{Combination: FilterCombinationAnd}},
		Sorts:      []*ViewSort{},
		PageSize:   ViewDefaultPageSize,
		LayoutType: LayoutTypeGallery,
		Gallery:    NewLayoutGallery(),
	}
}

func NewKanbanView() (ret *View) {
	return &View{
		ID:         ast.NewNodeID(),
		Name:       GetAttributeViewI18n("kanban"),
		Filters:    []*ViewFilter{{Combination: FilterCombinationAnd}},
		Sorts:      []*ViewSort{},
		PageSize:   ViewDefaultPageSize,
		LayoutType: LayoutTypeKanban,
		Kanban:     NewLayoutKanban(),
	}
}

// Viewable 描述了视图的接口。
type Viewable interface {

	// GetType 获取视图的布局类型。
	GetType() LayoutType

	// GetID 获取视图的 ID。
	GetID() string

	// SetGroups 设置视图分组列表。
	SetGroups(viewables []Viewable)

	// SetGroupCalc 设置视图分组计算规则和结果。
	SetGroupCalc(group *GroupCalc)

	// GetGroupCalc 获取视图分组计算规则和结果。
	GetGroupCalc() *GroupCalc

	// SetGroupFolded 设置分组是否折叠。
	SetGroupFolded(folded bool)

	// GetGroupHidden 获取分组是否隐藏。
	// hidden 0:显示,1:空白隐藏,2:手动隐藏
	GetGroupHidden() int

	// SetGroupHidden 设置分组是否隐藏。
	// hidden 0:显示,1:空白隐藏,2:手动隐藏
	SetGroupHidden(hidden int)
}

func NewAttributeView(id string) (ret *AttributeView) {
	view, blockKey, selectKey := NewTableViewWithBlockKey(ast.NewNodeID())
	ret = &AttributeView{
		Spec:              PlainTextSpec,
		ID:                id,
		KeyValues:         []*KeyValues{{Key: blockKey}, {Key: selectKey}},
		Views:             []*View{view},
		RenderedViewables: map[string]Viewable{},
	}
	return
}

func GetAttributeViewName(avID string) (ret string, err error) {
	// 通过 fallback 查找 AV 定义的真实路径(普通 box 全局,加密笔记本笔记本级)
	avJSONPath, boxID := FindAttributeViewPath(avID)
	if avJSONPath == "" {
		avJSONPath = GetAttributeViewDataPath(avID)
		boxID = ""
	}
	if !filelock.IsExist(avJSONPath) {
		return
	}

	return getAttributeViewNameByPathInBox(avJSONPath, boxID)
}

func getAttributeViewNameByPathInBox(avJSONPath, boxID string) (ret string, err error) {
	data, err := filelock.ReadFile(avJSONPath)
	if err != nil {
		logging.LogErrorf("read attribute view [%s] failed: %s", avJSONPath, err)
		return
	}
	if boxID != "" {
		avID := strings.TrimSuffix(filepath.Base(avJSONPath), filepath.Ext(avJSONPath))
		plain, decErr := decryptAVData(boxID, avID, data)
		if decErr != nil {
			logging.LogErrorf("decrypt attribute view [%s] failed: %s", avJSONPath, decErr)
			return "", decErr
		}
		data = plain
	}

	val := jsoniter.Get(data, "name")
	if nil == val || val.ValueType() == jsoniter.InvalidValue {
		return
	}
	ret = val.ToString()
	return
}

// GetAttributeViewNameInBox 获取指定笔记本中的数据库名称。
func GetAttributeViewNameInBox(avID, boxID string) (ret string, err error) {
	avJSONPath, _ := FindAttributeViewPathInBox(avID, boxID)
	if avJSONPath == "" {
		return
	}
	return getAttributeViewNameByPathInBox(avJSONPath, boxID)
}

type AttributeViewSearchView struct {
	ID         string     `json:"id"`
	Name       string     `json:"name"`
	LayoutType LayoutType `json:"type"`
}

type AttributeViewSearchInfo struct {
	Spec  int                        `json:"spec"`
	Name  string                     `json:"name"`
	Views []*AttributeViewSearchView `json:"views"`
}

func newAttributeViewSearchInfo(attrView *AttributeView) *AttributeViewSearchInfo {
	if attrView == nil {
		return nil
	}
	ret := &AttributeViewSearchInfo{Spec: attrView.Spec, Name: attrView.Name}
	for _, view := range attrView.Views {
		if view == nil {
			continue
		}
		ret.Views = append(ret.Views, &AttributeViewSearchView{
			ID:         view.ID,
			Name:       view.Name,
			LayoutType: view.LayoutType,
		})
	}
	return ret
}

func cacheAttributeViewData(attrView *AttributeView, boxID string, data []byte) {
	rememberCollectionView(attrView, boxID)
	version := cache.SetAVDataWithVersionInBox(attrView.ID, boxID, data)
	cache.SetAVSearchDataInBox(attrView.ID, boxID, version, newAttributeViewSearchInfo(attrView))
}

func parseAttributeViewSearchInfo(data []byte) (ret *AttributeViewSearchInfo, err error) {
	data = bytes.TrimPrefix(data, []byte("\xef\xbb\xbf"))
	ret = &AttributeViewSearchInfo{}
	if err = json.Unmarshal(data, ret); err != nil {
		return
	}
	for _, view := range ret.Views {
		if view != nil && view.LayoutType == "map" {
			view.LayoutType = LayoutTypeTable
		}
	}
	err = CheckSpec(&AttributeView{Spec: ret.Spec})
	return
}

var attributeViewSearchInfoFlight singleflight.Group

func GetAttributeViewSearchInfoInBox(avID, boxID string) (ret *AttributeViewSearchInfo, err error) {
	avJSONPath, avBoxID := FindAttributeViewPathInBox(avID, boxID)
	if avJSONPath == "" {
		return
	}
	if cached, ok := cache.GetAVSearchDataInBox[*AttributeViewSearchInfo](avID, avBoxID); ok {
		return cached, nil
	}

	value, err, _ := attributeViewSearchInfoFlight.Do(avBoxID+"\x00"+avID, func() (any, error) {
		return loadAttributeViewSearchInfoInBox(avID, avJSONPath, avBoxID)
	})
	if value != nil {
		ret = value.(*AttributeViewSearchInfo)
	}
	return
}

func loadAttributeViewSearchInfoInBox(avID, avJSONPath, avBoxID string) (ret *AttributeViewSearchInfo, err error) {
	release, lockErr := holdAVBoxReadLock(avBoxID)
	if lockErr != nil {
		return nil, lockErr
	}
	defer release()

	for range 3 {
		if cached, ok := cache.GetAVSearchDataInBox[*AttributeViewSearchInfo](avID, avBoxID); ok {
			return cached, nil
		}

		var data []byte
		var dataVersion uint64
		if cached, version, ok := cache.GetAVDataWithVersionInBox(avID, avBoxID); ok {
			data = cached
			dataVersion = version
		} else {
			dataVersion = cache.EnsureAVDataVersionInBox(avID, avBoxID)
			if data, err = filelock.ReadFile(avJSONPath); err != nil {
				logging.LogErrorf("read attribute view [%s] failed: %s", avJSONPath, err)
				return
			}
			if avBoxID != "" {
				if data, err = decryptAVDataLocked(avBoxID, avID, data); err != nil {
					logging.LogErrorf("decrypt attribute view [%s] failed: %s", avJSONPath, err)
					return
				}
			} else if util.IsCiphertext(data) {
				return nil, nil
			}
		}

		if ret, err = parseAttributeViewSearchInfo(data); err != nil {
			logging.LogErrorf("unmarshal attribute view search info [%s] failed: %s", avID, err)
			return nil, fmt.Errorf("parse attribute view search info [%s] failed: %w", avJSONPath, err)
		}
		if cache.SetAVSearchDataInBox(avID, avBoxID, dataVersion, ret) {
			return ret, nil
		}
	}
	err = fmt.Errorf("attribute view [%s] changed while loading search info", avID)
	logging.LogWarnf("%s", err)
	return nil, err
}

func GetAttributeViewContent(avID string) (content string) {
	if "" == avID {
		return
	}

	attrView, err := parseAttributeView(avID, false)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
		return
	}
	if nil == attrView {
		return
	}
	return getAttributeViewContent0(attrView)
}

func GetAttributeViewContentByPath(avJSONPath string) (content string) {
	attrView, err := parseAttributeViewByPathInBoxWithOptions(avJSONPath, avBoxIDFromPath(avJSONPath), false)
	if err != nil {
		logging.LogErrorf("parse attribute view [%s] failed: %s", avJSONPath, err)
		return
	}
	if nil == attrView {
		return
	}
	return getAttributeViewContent0(attrView)
}

func getAttributeViewContent0(attrView *AttributeView) (content string) {
	buf := bytes.Buffer{}
	buf.WriteString(attrView.Name)
	buf.WriteByte(' ')
	for _, v := range attrView.Views {
		buf.WriteString(v.Name)
		buf.WriteByte(' ')
	}

	for _, keyValues := range attrView.KeyValues {
		buf.WriteString(keyValues.Key.Name)
		buf.WriteByte(' ')
		for _, value := range keyValues.Values {
			if nil != value {
				buf.WriteString(value.String(true))
				buf.WriteByte(' ')
			}
		}
	}

	content = strings.TrimSpace(buf.String())
	return
}

func IsAttributeViewExist(avID string) bool {
	// 通过 fallback 查找(普通 box 全局,加密笔记本笔记本级)
	avJSONPath, _ := FindAttributeViewPath(avID)
	if avJSONPath == "" {
		avJSONPath = GetAttributeViewDataPath(avID)
	}
	return filelock.IsExist(avJSONPath)
}

func ParseAttributeView(avID string) (ret *AttributeView, err error) {
	return parseAttributeView(avID, true)
}

func parseAttributeView(avID string, resolveColors bool) (ret *AttributeView, err error) {
	if !ast.IsNodeIDPattern(avID) {
		err = ErrInvalidAttributeViewID
		return
	}

	// 加密笔记本的 AV 定义存笔记本级路径,通过 fallback 自动查找并解密
	avJSONPath, boxID := FindAttributeViewPath(avID)
	if avJSONPath == "" {
		// 文件不存在,可能是首次创建,按全局路径返回(由调用方处理)
		avJSONPath = GetAttributeViewDataPath(avID)
		return parseAttributeViewByPathInBoxWithOptions(avJSONPath, "", resolveColors)
	}
	if boxID != "" {
		SetAVBoxID(avID, boxID)
	}
	return parseAttributeViewByPathInBoxWithOptions(avJSONPath, boxID, resolveColors)
}

func ParseAttributeViewInBox(avID, boxID string) (ret *AttributeView, err error) {
	return parseAttributeViewInBox(avID, boxID, true)
}

// ParseAttributeViewForIndexInBox 读取索引所需的数据并保留解密认证,不解析显示配色,避免等待同步自身结束。
func ParseAttributeViewForIndexInBox(avID, boxID string) (ret *AttributeView, err error) {
	return parseAttributeViewInBox(avID, boxID, false)
}

func parseAttributeViewInBox(avID, boxID string, resolveColors bool) (ret *AttributeView, err error) {
	if !ast.IsNodeIDPattern(avID) {
		err = ErrInvalidAttributeViewID
		return
	}
	if boxID != "" && !ast.IsNodeIDPattern(boxID) {
		err = ErrInvalidBoxID
		return
	}

	avJSONPath, avBoxID := FindAttributeViewPathInBox(avID, boxID)
	if avJSONPath == "" {
		avJSONPath = attributeViewDataPathByBox(avID, boxID)
		avBoxID = boxID
	} else {
		// 只在文件确实存在于该 box 内时才设置映射,避免错误 boxID 污染后续路由
		if boxID != "" {
			SetAVBoxID(avID, boxID)
		}
	}
	return parseAttributeViewByPathInBoxWithOptions(avJSONPath, avBoxID, resolveColors)
}

func ParseAttributeViewByPath(avJSONPath string) (ret *AttributeView, err error) {
	return parseAttributeViewByPathInBox(avJSONPath, avBoxIDFromPath(avJSONPath))
}

func parseAttributeViewByPathInBox(avJSONPath, boxID string) (ret *AttributeView, err error) {
	return parseAttributeViewByPathInBoxWithOptions(avJSONPath, boxID, true)
}

// ReadAttributeViewCustomColorUsageByPath 读取属性视图持久化数据中的自定义颜色引用,但不解析派生颜色。
func ReadAttributeViewCustomColorUsageByPath(avJSONPath string) (avID string, indexes []int, err error) {
	avID = strings.TrimSuffix(filepath.Base(avJSONPath), filepath.Ext(avJSONPath))
	attrView, err := parseAttributeViewByPathInBoxWithOptions(avJSONPath, avBoxIDFromPath(avJSONPath), false)
	if err != nil {
		return avID, nil, err
	}
	if attrView == nil {
		return avID, nil, errors.New("attribute view content is unavailable")
	}
	return avID, attrView.UsedCustomColorIndexes(), nil
}

func parseAttributeViewByPathInBoxWithOptions(avJSONPath, boxID string, resolveColors bool) (ret *AttributeView, err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("load attribute view [%s] failed: %w", avJSONPath, err)
		}
	}()
	generation := cache.GetAVCacheGeneration()
	if !filelock.IsExist(avJSONPath) {
		err = ErrViewNotFound
		return
	}
	release, lockErr := holdAVBoxReadLock(boxID)
	if lockErr != nil {
		return nil, lockErr
	}
	defer release()

	avID := filepath.Base(avJSONPath)
	avID = strings.TrimSuffix(avID, filepath.Ext(avID))

	var data []byte
	var dataVersion uint64
	if cached, version, ok := cache.GetAVDataWithVersionInBox(avID, boxID); ok {
		data = cached
		dataVersion = version
	} else {
		var readErr error
		readVersion := cache.AVDataReadVersion()
		data, readErr = filelock.ReadFile(avJSONPath)
		if nil != readErr {
			logging.LogErrorf("read attribute view [%s] failed: %s", avID, readErr)
			return nil, readErr
		}
		// 加密笔记本的 AV 定义是密文,按路径反查 boxID 后解密
		if boxID != "" {
			data, readErr = decryptAVDataLocked(boxID, avID, data)
			if readErr != nil {
				logging.LogErrorf("decrypt attribute view [%s] failed: %s", avID, readErr)
				return nil, readErr
			}
		} else if util.IsCiphertext(data) {
			// 历史等无法取得 boxID/DEK 的全局路径上读到密文:无法解密,返回空内容而非按 JSON 解析报错。
			// 这会在加密笔记本的 AV 因路径迁移(同步、导入、历史布局)落到全局位置时发生。
			return nil, nil
		}
		dataVersion = cache.SetAVDataFromReadInBox(avID, boxID, data, readVersion)
	}

	if normalized, ok := cache.GetAVNormalizedDataInBox(avID, boxID, dataVersion); ok {
		ret, err = parseAttributeViewData(avID, normalized, false)
	} else {
		ret, err = ParseAttributeViewData(avID, data)
		if err == nil {
			if normalized, marshalErr := json.Marshal(ret); marshalErr == nil {
				cache.SetAVNormalizedDataInBox(avID, boxID, dataVersion, data, normalized)
			}
		}
	}
	if nil == err {
		ret.sourceVersion, ret.sourceGeneration = dataVersion, generation
		ret.liveOrdinarySource = boxID == "" && filepath.Clean(avJSONPath) == filepath.Join(util.DataDir, "storage", "av", avID+".json")
		if resolveColors {
			ret.ResolveDirectColors()
			cache.SetAVSearchDataInBox(avID, boxID, dataVersion, newAttributeViewSearchInfo(ret))
		}
	}
	return
}

// ParseAttributeViewData 解析已经完成解密认证的数据库数据,复用现有格式兼容与规范化处理。
func ParseAttributeViewData(avID string, data []byte) (ret *AttributeView, err error) {
	return parseAttributeViewData(avID, data, true)
}

func parseAttributeViewData(avID string, data []byte, normalizeRichText bool) (ret *AttributeView, err error) {
	// 仅处理已认证明文的开头 BOM;缓存和条件写入保留原始字节以检测外部修改。
	data = bytes.TrimPrefix(data, []byte("\xef\xbb\xbf"))
	ret = &AttributeView{RenderedViewables: map[string]Viewable{}}
	if err = json.Unmarshal(data, ret); err != nil {
		if strings.Contains(err.Error(), ".relation.contents of type av.Value") {
			mapAv := map[string]any{}
			if err = json.Unmarshal(data, &mapAv); err != nil {
				logging.LogErrorf("unmarshal attribute view [%s] failed: %s", avID, err)
				return
			}

			// v3.0.3 兼容之前旧版本,将 relation.contents[""] 转换为 null
			keyValues := mapAv["keyValues"]
			keyValuesMap := keyValues.([]any)
			for _, kv := range keyValuesMap {
				kvMap := kv.(map[string]any)
				if values := kvMap["values"]; nil != values {
					valuesMap := values.([]any)
					for _, v := range valuesMap {
						if vMap := v.(map[string]any); nil != vMap["relation"] {
							vMap["relation"].(map[string]any)["contents"] = nil
						}
					}
				}
			}

			views := mapAv["views"]
			viewsMap := views.([]any)
			for _, view := range viewsMap {
				if table := view.(map[string]any)["table"]; nil != table {
					tableMap := table.(map[string]any)
					if filters := tableMap["filters"]; nil != filters {
						filtersMap := filters.([]any)
						for _, f := range filtersMap {
							if fMap := f.(map[string]any); nil != fMap["value"] {
								if valueMap := fMap["value"].(map[string]any); nil != valueMap["relation"] {
									valueMap["relation"].(map[string]any)["contents"] = nil
								}
							}
						}
					}
				}
			}

			data, err = json.Marshal(mapAv)
			if err != nil {
				logging.LogErrorf("marshal attribute view [%s] failed: %s", avID, err)
				return
			}

			if err = json.Unmarshal(data, ret); err != nil {
				logging.LogErrorf("unmarshal attribute view [%s] failed: %s", avID, err)
				return
			}
		} else {
			logging.LogErrorf("unmarshal attribute view [%s] failed: %s", avID, err)
			return
		}
	}
	if nil == err {
		err = CheckSpec(ret)
	}
	if err == nil {
		err = ret.Automations.ValidateSpec()
	}
	if nil == err {
		err = ret.ValidateLayouts()
	}
	if nil == err && normalizeRichText {
		err = ret.NormalizeRichText()
	}
	if nil == err {
		err = ret.NormalizeLocations()
	}
	return
}

func SaveAttributeView(av *AttributeView) (err error) {
	return saveAttributeView(av, nil)
}

// SaveAttributeViewIfUnchanged 仅在全局数据库仍与扫描源一致时原子保存。
func SaveAttributeViewIfUnchanged(av *AttributeView, original []byte) error {
	if original == nil {
		return errors.New("attribute view source is required")
	}
	return saveAttributeView(av, original)
}

func saveAttributeView(av *AttributeView, original []byte) (err error) {
	if av.Spec > CurrentSpec {
		return ErrSpecTooNew
	}
	if !ast.IsNodeIDPattern(av.ID) {
		err = ErrInvalidAttributeViewID
		logging.LogErrorf("save attribute view failed: %s", err)
		return
	}
	defer func() {
		if nil == err {
			av.ResetCardCoverPositionChanges()
		}
	}()

	if err = av.NormalizeLocations(); nil != err {
		return
	}
	if err = av.ValidateLayouts(); nil != err {
		return
	}
	if err = av.NormalizeRichText(); nil != err {
		logging.LogErrorf("normalize attribute view [%s] rich text failed: %s", av.ID, err)
		return
	}

	// 做一些数据兼容和订正处理
	UpgradeSpec(av)

	// 值去重
	blockValues := av.GetBlockKeyValues()
	if nil != blockValues {
		blockIDs := map[string]bool{}
		var duplicatedValueIDs []string
		for _, blockValue := range blockValues.Values {
			if !blockIDs[blockValue.BlockID] {
				blockIDs[blockValue.BlockID] = true
			} else {
				duplicatedValueIDs = append(duplicatedValueIDs, blockValue.ID)
			}
		}
		var tmp []*Value
		for _, blockValue := range blockValues.Values {
			if !gulu.Str.Contains(blockValue.ID, duplicatedValueIDs) {
				tmp = append(tmp, blockValue)
			}
		}
		blockValues.Values = tmp
	}

	// 视图值去重
	for _, view := range av.Views {
		// 项目自定义排序去重
		view.ItemIDs = gulu.Str.RemoveDuplicatedElem(view.ItemIDs)

		// 分页大小
		if 1 > view.PageSize {
			view.PageSize = ViewDefaultPageSize
		}
	}

	// 清理渲染回填值
	for _, kv := range av.KeyValues {
		for i, v := range slices.Backward(kv.Values) {
			if v.IsRenderAutoFill {
				kv.Values = append(kv.Values[:i], kv.Values[i+1:]...)
			}
		}
	}

	var data []byte
	restoreRenderedContents := av.suspendRenderedContents()
	restoreResolvedColors := av.suspendResolvedColors()
	if util.UseSingleLineSave.Load() {
		data, err = gulu.JSON.MarshalJSON(av)
	} else {
		data, err = gulu.JSON.MarshalIndentJSON(av, "", "\t")
	}
	restoreResolvedColors()
	restoreRenderedContents()
	if err != nil {
		logging.LogErrorf("marshal attribute view [%s] failed: %s", av.ID, err)
		return
	}

	// 缓存与待写入数据一致时跳过落盘;缓存未命中时再读盘比对,避免无变更的重复写入
	// 通过 fallback 查找 AV 定义的实际路径(普通 box 全局,加密笔记本笔记本级)
	avJSONPath, avBoxID := FindAttributeViewPath(av.ID)
	releaseBox, lockErr := holdAVBoxReadLock(avBoxID)
	if lockErr != nil {
		return lockErr
	}
	defer releaseBox()
	if avJSONPath == "" {
		// 文件不存在(首次创建),使用全局路径,boxID 为空(普通 box)
		// 加密笔记本的首次创建由 handler 层通过 SetAVBoxID 预设路径
		avJSONPath = GetAttributeViewDataPath(av.ID)
	}
	if value, recorded := sourceWriteRecorders.Load(avBoxID + "/" + av.ID); recorded && value.(*sourceWriteRecord).active() {
		before, readErr := filelock.ReadFile(avJSONPath)
		if os.IsNotExist(readErr) {
			before, readErr = nil, nil
		}
		if readErr != nil {
			return readErr
		}
		if original != nil {
			if avBoxID != "" {
				return errors.New("conditional replacement of encrypted attribute views is not supported")
			}
			if !bytes.Equal(before, original) {
				return util.ErrFileChanged
			}
		}
		if before != nil {
			plain := before
			if avBoxID != "" {
				plain, readErr = decryptAVDataLocked(avBoxID, av.ID, before)
			}
			if readErr != nil {
				return readErr
			}
			if _, readErr = ParseAttributeViewData(av.ID, plain); readErr != nil {
				return readErr
			}
		}
		writeData := data
		if avBoxID != "" {
			if writeData, err = encryptAVDataLocked(avBoxID, av.ID, data); err != nil {
				return err
			}
		}
		if err = value.(*sourceWriteRecord).record(avBoxID, before, writeData); err != nil {
			return err
		}
		if err = os.MkdirAll(filepath.Dir(avJSONPath), 0755); err != nil {
			return err
		}
		if err = util.WriteFileIfUnchanged(avJSONPath, before, writeData); err != nil {
			return err
		}
		cacheAttributeViewData(av, avBoxID, data)
		NotifyAttributeViewSaved(av.ID, avBoxID)
		return nil
	}
	if original != nil {
		if avBoxID != "" {
			return errors.New("conditional replacement of encrypted attribute views is not supported")
		}
		if err = util.WriteFileIfUnchanged(avJSONPath, original, data); err != nil {
			return err
		}
		cacheAttributeViewData(av, avBoxID, data)
		NotifyAttributeViewSaved(av.ID, avBoxID)
		return nil
	}
	if cachedData, version, ok := cache.GetAVDataWithVersionInBox(av.ID, avBoxID); ok {
		if len(cachedData) == len(data) && bytes.Equal(cachedData, data) {
			cache.SetAVSearchDataInBox(av.ID, avBoxID, version, newAttributeViewSearchInfo(av))
			return
		}
	} else {
		if diskData, readErr := filelock.ReadFile(avJSONPath); nil == readErr {
			// 加密笔记本的磁盘数据是密文,需先解密再比对
			if avBoxID != "" {
				diskData, _ = decryptAVDataLocked(avBoxID, av.ID, diskData)
			}
			if len(diskData) == len(data) && bytes.Equal(diskData, data) {
				cacheAttributeViewData(av, avBoxID, data)
				return
			}
		}
	}

	// 加密笔记本的数据需加密后再写盘
	writeData := data
	if avBoxID != "" {
		writeData, err = encryptAVDataLocked(avBoxID, av.ID, data)
		if err != nil {
			logging.LogErrorf("encrypt attribute view [%s] failed: %s", av.ID, err)
			return
		}
	}
	// 确保目录存在(加密笔记本的笔记本级 AV 目录可能尚不存在)
	if err = os.MkdirAll(filepath.Dir(avJSONPath), 0755); nil != err {
		logging.LogErrorf("create attribute view dir [%s] failed: %s", filepath.Dir(avJSONPath), err)
		return
	}
	if avBoxID != "" {
		// 密文通过临时文件原子替换,避免原址覆写中断后丢失可认证的旧数据。
		if err = filelock.WriteFile(avJSONPath, writeData); nil != err {
			logging.LogErrorf("save attribute view [%s] failed: %s", av.ID, err)
			return
		}
	} else if err = util.WriteFileByMmap(avJSONPath, writeData); nil != err {
		if err = filelock.WriteFile(avJSONPath, writeData); nil != err {
			logging.LogErrorf("save attribute view [%s] failed: %s", av.ID, err)
			return
		}
	}

	cacheAttributeViewData(av, avBoxID, data)
	NotifyAttributeViewSaved(av.ID, avBoxID)

	if util.ExceedLargeFileWarningSize(len(data)) {
		msg := fmt.Sprintf(util.Langs[util.Lang][268], av.Name+" "+filepath.Base(avJSONPath), util.LargeFileWarningSize.Load())
		util.PushErrMsg(msg, 7000)
	}
	return
}

func (av *AttributeView) GetView(viewID string) (ret *View) {
	for _, v := range av.Views {
		if nil != v && v.ID == viewID {
			ret = v
			return
		}
	}
	return
}

// GetVisibleViewIDs 根据数据库块属性返回可见视图 ID,并按数据库中的视图顺序排列。
func (av *AttributeView) GetVisibleViewIDs(value string) (ret []string) {
	value = strings.TrimSpace(value)
	if "" == value {
		for _, view := range av.Views {
			if nil != view && "" != view.ID {
				ret = append(ret, view.ID)
			}
		}
		return
	}

	visible := map[string]bool{}
	for viewID := range strings.SplitSeq(value, ",") {
		viewID = strings.TrimSpace(viewID)
		if "" != viewID {
			visible[viewID] = true
		}
	}
	for _, view := range av.Views {
		if nil != view && visible[view.ID] {
			ret = append(ret, view.ID)
		}
	}
	if 1 > len(ret) {
		if view, _ := av.GetFirstView(); nil != view {
			ret = append(ret, view.ID)
		}
	}
	return
}

func (av *AttributeView) GetFirstView() (ret *View, err error) {
	for _, view := range av.Views {
		if nil != view && "" != view.ID {
			return view, nil
		}
	}
	return nil, ErrViewNotFound
}

func (av *AttributeView) ExistBoundBlock(nodeID string) bool {
	for _, blockVal := range av.GetBlockKeyValues().Values {
		if blockVal.Block.ID == nodeID {
			return true
		}
	}
	return false
}

func (av *AttributeView) GetBlockValueByBoundID(nodeID string) *Value {
	for _, kv := range av.KeyValues {
		if KeyTypeBlock == kv.Key.Type {
			for _, v := range kv.Values {
				if v.Block.ID == nodeID {
					return v
				}
			}
		}
	}
	return nil
}

func (av *AttributeView) GetValue(keyID, itemID string) (ret *Value) {
	for _, kv := range av.KeyValues {
		if kv.Key.ID == keyID {
			for _, v := range kv.Values {
				if v.BlockID == itemID {
					ret = v
					return
				}
			}
		}
	}
	return
}

func (av *AttributeView) GetKey(keyID string) (ret *Key, err error) {
	for _, kv := range av.KeyValues {
		if kv.Key.ID == keyID {
			ret = kv.Key
			return
		}
	}
	err = ErrKeyNotFound
	return
}

func (av *AttributeView) GetBlockKeyValues() (ret *KeyValues) {
	for _, kv := range av.KeyValues {
		if KeyTypeBlock == kv.Key.Type {
			ret = kv
			return
		}
	}
	return
}

func (av *AttributeView) GetBlockValue(itemID string) (ret *Value) {
	for _, kv := range av.KeyValues {
		if KeyTypeBlock == kv.Key.Type && 0 < len(kv.Values) {
			for _, v := range kv.Values {
				if v.BlockID == itemID {
					ret = v
					return
				}
			}
		}
	}
	return
}

func (av *AttributeView) GetKeyValues(keyID string) (ret *KeyValues, err error) {
	for _, kv := range av.KeyValues {
		if kv.Key.ID == keyID {
			ret = kv
			return
		}
	}
	err = ErrKeyNotFound
	return
}

func (av *AttributeView) GetBlockKey() (ret *Key) {
	for _, kv := range av.KeyValues {
		if KeyTypeBlock == kv.Key.Type {
			ret = kv.Key
			return
		}
	}
	return
}

func (av *AttributeView) Clone() (ret *AttributeView) {
	ret = &AttributeView{}
	data, err := gulu.JSON.MarshalJSON(av)
	if err != nil {
		logging.LogErrorf("marshal attribute view [%s] failed: %s", av.ID, err)
		return nil
	}
	if err = gulu.JSON.UnmarshalJSON(data, ret); err != nil {
		logging.LogErrorf("unmarshal attribute view [%s] failed: %s", av.ID, err)
		return nil
	}

	ret.ID = ast.NewNodeID()
	templateIDMap := map[string]string{}
	for _, itemTemplate := range ret.NewItemTemplates {
		if nil == itemTemplate {
			continue
		}
		oldID := itemTemplate.ID
		itemTemplate.ID = ast.NewNodeID()
		templateIDMap[oldID] = itemTemplate.ID
	}
	ret.DefaultTemplateID = templateIDMap[ret.DefaultTemplateID]
	if 1 > len(ret.Views) {
		logging.LogErrorf("attribute view [%s] has no views", av.ID)
		return nil
	}

	var oldKeyIDs []string
	keyIDMap := map[string]string{}
	keyTypeMap := map[string]KeyType{}
	for _, kv := range ret.KeyValues {
		newID := ast.NewNodeID()
		keyIDMap[kv.Key.ID] = newID
		keyTypeMap[kv.Key.ID] = kv.Key.Type
		oldKeyIDs = append(oldKeyIDs, kv.Key.ID)
		kv.Key.ID = newID
		kv.Values = []*Value{}

		if KeyTypeRelation == kv.Key.Type {
			// 断开关联
			kv.Key.Relation.IsTwoWay = false
			kv.Key.Relation.AvID = ""
			kv.Key.Relation.BackKeyID = ""
		}
	}

	for _, itemTemplate := range ret.NewItemTemplates {
		if nil == itemTemplate {
			continue
		}
		fieldValues := map[string]*NewItemFieldValue{}
		for oldKeyID, fieldValue := range itemTemplate.FieldValues {
			newKeyID, ok := keyIDMap[oldKeyID]
			if !ok || KeyTypeRelation == keyTypeMap[oldKeyID] {
				continue
			}
			fieldValues[newKeyID] = fieldValue
		}
		if 0 == len(fieldValues) {
			itemTemplate.FieldValues = nil
		} else {
			itemTemplate.FieldValues = fieldValues
		}
	}

	ret.remapAutomationKeys(av.ID, keyIDMap)
	oldKeyIDs = gulu.Str.RemoveDuplicatedElem(oldKeyIDs)
	sorts := map[string]int{}
	for i, k := range ret.KeyIDs {
		sorts[k] = i
	}
	sort.Slice(oldKeyIDs, func(i, j int) bool {
		return sorts[oldKeyIDs[i]] < sorts[oldKeyIDs[j]]
	})

	for _, view := range ret.Views {
		view.ID = ast.NewNodeID()

		remapFilterColumns(view.Filters, keyIDMap)
		for _, rule := range view.ConditionalColors {
			if nil != rule {
				rule.ID = ast.NewNodeID()
				remapFilterColumns([]*ViewFilter{rule.Filter}, keyIDMap)
			}
		}
		for _, s := range view.Sorts {
			s.Column = keyIDMap[s.Column]
		}

		if nil != view.Group {
			view.Group.Field = keyIDMap[view.Group.Field]
		}

		for _, layout := range view.TableLayouts() {
			if nil == layout {
				continue
			}
			layout.ID = ast.NewNodeID()
			for _, column := range layout.Columns {
				column.ID = keyIDMap[column.ID]
			}
		}
		if nil != view.Calendar {
			if id := keyIDMap[view.Calendar.Settings.DateKeyID]; id != "" {
				view.Calendar.Settings.DateKeyID = id
			}
			if id := keyIDMap[view.Calendar.Settings.ColorKeyID]; id != "" {
				view.Calendar.Settings.ColorKeyID = id
			}
		}
		if nil != view.Gallery {
			view.Gallery.ID = ast.NewNodeID()
			for _, cardField := range view.Gallery.CardFields {
				cardField.ID = keyIDMap[cardField.ID]
			}
		}
		if nil != view.Kanban {
			view.Kanban.ID = ast.NewNodeID()
			for _, field := range view.Kanban.Fields {
				field.ID = keyIDMap[field.ID]
			}
		}
		view.ItemIDs = []string{}
	}
	ret.CardCoverPositions = nil

	ret.KeyIDs = nil
	for _, oldKeyID := range oldKeyIDs {
		newKeyID := keyIDMap[oldKeyID]
		ret.KeyIDs = append(ret.KeyIDs, newKeyID)
	}
	return
}

func GetAttributeViewDataPath(avID string) (ret string) {
	if !ast.IsNodeIDPattern(avID) {
		return
	}

	av := filepath.Join(util.DataDir, "storage", "av")
	ret = filepath.Join(av, avID+".json")
	if !gulu.File.IsDir(av) {
		if err := os.MkdirAll(av, 0755); err != nil {
			logging.LogErrorf("create attribute view dir failed: %s", err)
			return
		}
	}
	return
}

func GetAttributeViewI18n(key string) string {
	return util.AttrViewLangs[util.Lang][key].(string)
}

var (
	ErrAttributeViewNotFound  = errors.New("attribute view not found")
	ErrInvalidAttributeViewID = errors.New("invalid attribute view id")
	ErrInvalidBoxID           = errors.New("invalid box id")
	ErrViewNotFound           = errors.New("view not found")
	ErrKeyNotFound            = errors.New("key not found")
	ErrItemNotFound           = errors.New("item not found")
	ErrWrongLayoutType        = errors.New("wrong layout type")
	ErrInvalidColumnAlign     = errors.New("invalid column align")
	ErrSpecTooNew             = errors.New("attribute view spec is too new")
	ErrRichTextSpecMismatch   = errors.New("attribute view rich text requires storage spec 9")
	ErrLocationSpecMismatch   = errors.New("attribute view location requires storage spec 13")
	ErrFilterTooDeep          = errors.New("filter nesting depth exceeds the maximum allowed")
)

const (
	NodeAttrNameAvs        = "custom-avs"                  // 用于标记块所属的属性视图,逗号分隔 av id
	NodeAttrView           = "custom-sy-av-view"           // 用于标记块所属的属性视图视图 view id Database block support specified view https://github.com/siyuan-note/siyuan/issues/10443
	NodeAttrVisibleViewIDs = "custom-sy-av-visible-views"  // 用于标记数据库块显示的视图 ID,逗号分隔
	NodeAttrContextFilter  = "custom-sy-av-context-filter" // 用于保存数据库块独有的上下文筛选配置
	NodeAttrViewStaticText = "custom-sy-av-s-text"         // 用于标记块所属的属性视图静态文本 Database-bound block primary key supports setting static anchor text https://github.com/siyuan-note/siyuan/issues/10049

	NodeAttrViewNames = "av-names" // 用于临时标记块所属的属性视图名称,空格分隔
)