Skip to content

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

5.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

type renderedContentBinding struct {
	value       *Value
	content     string
	hasTemplate bool
}

// CloneStoredValue 复制字段存储值,并递归剥离运行时显示模板结果。
func CloneStoredValue(value *Value) (ret *Value) {
	if nil == value {
		return
	}
	cloned := *value
	cloned.RenderedContent = ""
	cloned.HasRenderTemplate = false
	ret = &cloned
	if nil != value.Relation {
		relation := *value.Relation
		relation.Contents = cloneStoredValues(value.Relation.Contents)
		ret.Relation = &relation
	}
	if nil != value.Rollup {
		rollup := *value.Rollup
		rollup.Contents = cloneStoredValues(value.Rollup.Contents)
		ret.Rollup = &rollup
	}
	return
}

func cloneStoredValues(values []*Value) (ret []*Value) {
	if nil == values {
		return
	}
	ret = make([]*Value, 0, len(values))
	for _, value := range values {
		ret = append(ret, CloneStoredValue(value))
	}
	return
}

// suspendRenderedContents 在序列化属性视图期间剥离运行时显示模板结果,并在序列化后恢复。
func (av *AttributeView) suspendRenderedContents() (restore func()) {
	var bindings []renderedContentBinding
	if nil != av {
		av.visitPersistedValues(func(value *Value) {
			if "" == value.RenderedContent && !value.HasRenderTemplate {
				return
			}
			bindings = append(bindings, renderedContentBinding{value: value, content: value.RenderedContent,
				hasTemplate: value.HasRenderTemplate})
			value.RenderedContent = ""
			value.HasRenderTemplate = false
		})
	}
	return func() {
		for _, binding := range bindings {
			binding.value.RenderedContent = binding.content
			binding.value.HasRenderTemplate = binding.hasTemplate
		}
	}
}

// VisitPersistedValues 遍历属性视图中所有会持久化的值,每个值仅访问一次。
func (av *AttributeView) VisitPersistedValues(visit func(*Value)) {
	if nil == av || nil == visit {
		return
	}
	av.visitPersistedValues(visit)
}

func (av *AttributeView) visitPersistedValues(visit func(*Value)) {
	visited := map[*Value]struct{}{}
	var visitValue func(value *Value)
	visitValue = func(value *Value) {
		if nil == value {
			return
		}
		if _, ok := visited[value]; ok {
			return
		}
		visited[value] = struct{}{}
		visit(value)
		if nil != value.Relation {
			for _, content := range value.Relation.Contents {
				visitValue(content)
			}
		}
		if nil != value.Rollup {
			for _, content := range value.Rollup.Contents {
				visitValue(content)
			}
		}
	}

	for _, keyValues := range av.KeyValues {
		if nil == keyValues {
			continue
		}
		visitKeyValues(keyValues.Key, visitValue)
		for _, value := range keyValues.Values {
			visitValue(value)
		}
	}
	for _, view := range av.Views {
		visitViewValues(view, visitValue)
	}
	for _, itemTemplate := range av.NewItemTemplates {
		if nil == itemTemplate {
			continue
		}
		for _, fieldValue := range itemTemplate.FieldValues {
			if nil != fieldValue {
				visitValue(fieldValue.Value)
			}
		}
	}
	av.visitAutomationValues(visitValue)
}

func visitKeyValues(key *Key, visitValue func(*Value)) {
	if nil == key {
		return
	}
	if nil != key.Relation {
		visitFilterValues(key.Relation.CandidateFilters, visitValue)
	}
	if nil != key.Rollup {
		visitFilterValues(key.Rollup.Filters, visitValue)
		if nil != key.Rollup.Calc {
			visitValue(key.Rollup.Calc.Result)
		}
	}
}

func visitFilterValues(filters []*ViewFilter, visitValue func(*Value)) {
	for _, filter := range filters {
		if nil == filter {
			continue
		}
		visitValue(filter.Value)
		visitFilterValues(filter.Filters, visitValue)
	}
}

func visitViewValues(view *View, visitValue func(*Value)) {
	if nil == view {
		return
	}
	visitKeyValues(view.GroupKey, visitValue)
	visitValue(view.GroupVal)
	visitFilterValues(view.Filters, visitValue)
	for _, rule := range view.ConditionalColors {
		if nil != rule {
			visitFilterValues([]*ViewFilter{rule.Filter}, visitValue)
		}
	}
	if nil != view.GroupCalc && nil != view.GroupCalc.FieldCalc {
		visitValue(view.GroupCalc.FieldCalc.Result)
	}
	for _, layout := range view.TableLayouts() {
		if nil == layout {
			continue
		}
		if nil != layout.BaseLayout {
			visitFilterValues(layout.Filters, visitValue)
		}
		for _, column := range layout.Columns {
			if nil == column {
				continue
			}
			visitBaseFieldValue(column.BaseField, visitValue)
			if nil != column.Calc {
				visitValue(column.Calc.Result)
			}
		}
	}
	if nil != view.Gallery {
		if nil != view.Gallery.BaseLayout {
			visitFilterValues(view.Gallery.Filters, visitValue)
		}
		for _, field := range view.Gallery.CardFields {
			if nil != field {
				visitBaseFieldValue(field.BaseField, visitValue)
			}
		}
	}
	if nil != view.Kanban {
		if nil != view.Kanban.BaseLayout {
			visitFilterValues(view.Kanban.Filters, visitValue)
		}
		for _, field := range view.Kanban.Fields {
			if nil != field {
				visitBaseFieldValue(field.BaseField, visitValue)
			}
		}
	}
	for _, group := range view.Groups {
		visitViewValues(group, visitValue)
	}
}

func visitBaseFieldValue(field *BaseField, visitValue func(*Value)) {
	if nil != field && nil != field.Calc {
		visitValue(field.Calc.Result)
	}
}