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 (
"errors"
"fmt"
"math"
"os"
"path/filepath"
"slices"
"sort"
"strconv"
"strings"
"time"
"github.com/88250/gulu"
"github.com/88250/lute/ast"
"github.com/siyuan-note/dejavu/entity"
"github.com/siyuan-note/filelock"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/av"
"github.com/siyuan-note/siyuan/kernel/sql"
"github.com/siyuan-note/siyuan/kernel/util"
)
type AttributeViewRenderTarget struct {
Status string `json:"status"`
ItemID string `json:"itemID"`
GroupID string `json:"groupID,omitempty"`
Index int `json:"index"`
Offset int `json:"offset"`
PageSize int `json:"pageSize"`
}
type AttributeViewSearchTarget struct {
AvID string `json:"avID"`
DatabaseBlockID string `json:"databaseBlockID"`
NotebookID string `json:"notebookID"`
ViewID string `json:"viewID,omitempty"`
GroupID string `json:"groupID,omitempty"`
ItemID string `json:"itemID"`
ValueID string `json:"valueID"`
MatchedValueID string `json:"matchedValueID"`
MatchedKeyID string `json:"matchedKeyID"`
Title string `json:"title"`
BoundBlockID string `json:"boundBlockID"`
IsDetached bool `json:"isDetached"`
Keywords []string `json:"keywords"`
}
type attributeViewSearchMatch struct {
valueID string
keyID string
}
type attributeViewSearchItem struct {
itemID string
groupID string
}
func GetAttributeViewSearchTarget(blockID string, keywords []string) (ret *AttributeViewSearchTarget) {
waitForSyncingStorages()
node, tree, _ := getNodeByBlockID(nil, blockID)
if nil == node || nil == tree || ast.NodeAttributeView != node.Type || "" == node.AttributeViewID {
return
}
var attrView *av.AttributeView
var err error
if IsEncryptedBox(tree.Box) {
attrView, err = av.ParseAttributeViewInBox(node.AttributeViewID, tree.Box)
} else {
attrView, err = av.ParseAttributeView(node.AttributeViewID)
}
if nil == attrView {
logging.LogErrorf("parse attribute view [%s] failed: %s", node.AttributeViewID, err)
return
}
keywords = normalizeAttributeViewSearchKeywords(keywords)
if 1 > len(keywords) {
return
}
matches := getAttributeViewSearchMatches(attrView, keywords)
if 1 > len(matches) {
return
}
var orderedItems []attributeViewSearchItem
viewID := ""
blockValues := attrView.GetBlockKeyValues()
pageSize := len(matches) + 1
if nil != blockValues && len(blockValues.Values) >= pageSize {
pageSize = len(blockValues.Values) + 1
}
viewable, renderErr := renderAttributeView(attrView, blockID, "", "", "", 1, pageSize, nil, false, false, nil, "")
if nil == renderErr && nil != viewable {
viewID = viewable.GetID()
orderedItems = appendAttributeViewSearchItems(orderedItems, viewable, false)
orderedItems = appendAttributeViewSearchItems(orderedItems, viewable, true)
} else if nil != renderErr {
logging.LogWarnf("render attribute view [%s] for search target failed: %s", attrView.ID, renderErr)
}
if nil != blockValues {
for _, value := range blockValues.Values {
if nil != value {
orderedItems = append(orderedItems, attributeViewSearchItem{itemID: value.BlockID})
}
}
}
visited := map[string]bool{}
for _, item := range orderedItems {
if visited[item.itemID] {
continue
}
visited[item.itemID] = true
match := matches[item.itemID]
if nil == match {
continue
}
blockValue := attrView.GetBlockValue(item.itemID)
if nil == blockValue || nil == blockValue.Block {
continue
}
ret = &AttributeViewSearchTarget{
AvID: attrView.ID,
DatabaseBlockID: blockID,
NotebookID: tree.Box,
ViewID: viewID,
GroupID: item.groupID,
ItemID: item.itemID,
ValueID: blockValue.ID,
MatchedValueID: match.valueID,
MatchedKeyID: match.keyID,
Title: blockValue.String(true),
BoundBlockID: blockValue.Block.ID,
IsDetached: blockValue.IsDetached || "" == blockValue.Block.ID,
Keywords: keywords,
}
return
}
return
}
func normalizeAttributeViewSearchKeywords(keywords []string) (ret []string) {
added := map[string]bool{}
for _, keyword := range keywords {
keyword = strings.TrimSpace(keyword)
if "" == keyword || added[keyword] {
continue
}
added[keyword] = true
ret = append(ret, keyword)
}
return
}
func getAttributeViewSearchMatches(attrView *av.AttributeView, keywords []string) (ret map[string]*attributeViewSearchMatch) {
ret = map[string]*attributeViewSearchMatch{}
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
for _, value := range keyValues.Values {
if nil == value || "" == value.BlockID || nil != ret[value.BlockID] {
continue
}
content := value.String(true)
for _, keyword := range keywords {
if strings.Contains(content, keyword) {
ret[value.BlockID] = &attributeViewSearchMatch{valueID: value.ID, keyID: keyValues.Key.ID}
break
}
}
}
}
return
}
func appendAttributeViewSearchItems(items []attributeViewSearchItem, viewable av.Viewable, hiddenGroups bool) []attributeViewSearchItem {
if nil == viewable {
return items
}
baseInstance := getAttributeViewBaseInstance(viewable)
if nil != baseInstance && 0 < len(baseInstance.Groups) {
for _, group := range baseInstance.Groups {
if (0 != group.GetGroupHidden()) != hiddenGroups {
continue
}
if collection, ok := group.(av.Collection); ok {
for _, item := range collection.GetItems() {
items = append(items, attributeViewSearchItem{itemID: item.GetID(), groupID: group.GetID()})
}
}
}
return items
}
if hiddenGroups {
return items
}
if collection, ok := viewable.(av.Collection); ok {
for _, item := range collection.GetItems() {
items = append(items, attributeViewSearchItem{itemID: item.GetID()})
}
}
return items
}
func GetAttributeViewItemStatuses(blockID, avID, viewID, query string, itemIDs []string) (ret map[string]string, err error) {
viewable, attrView, _, err := RenderAttributeViewWithTarget(blockID, avID, viewID, query, 1, math.MaxInt, nil, "", false, false, "", "")
if nil != err {
return nil, err
}
return getAttributeViewItemStatuses(attrView, viewable, itemIDs), nil
}
func getAttributeViewItemStatuses(attrView *av.AttributeView, viewable av.Viewable, itemIDs []string) (ret map[string]string) {
ret = map[string]string{}
requested := map[string]bool{}
for _, itemID := range itemIDs {
if "" == itemID || requested[itemID] {
continue
}
requested[itemID] = true
ret[itemID] = "itemNotFound"
}
if blockValues := attrView.GetBlockKeyValues(); nil != blockValues {
for _, value := range blockValues.Values {
if nil != value && requested[value.BlockID] {
ret[value.BlockID] = "filtered"
}
}
}
for _, item := range appendAttributeViewSearchItems(nil, viewable, true) {
if requested[item.itemID] && "filtered" == ret[item.itemID] {
ret[item.itemID] = "groupHidden"
}
}
for _, item := range appendAttributeViewSearchItems(nil, viewable, false) {
if requested[item.itemID] {
ret[item.itemID] = "visible"
}
}
return
}
func getAttributeViewBaseInstance(viewable av.Viewable) (ret *av.BaseInstance) {
switch instance := viewable.(type) {
case *av.Table:
ret = instance.BaseInstance
case *av.Calendar:
ret = instance.BaseInstance
case *av.List:
ret = instance.BaseInstance
case *av.Gallery:
ret = instance.BaseInstance
case *av.Kanban:
ret = instance.BaseInstance
}
return
}
func RenderAttributeView(blockID, avID, viewID, query string, page, pageSize int, groupPaging map[string]any, createIfNotExist, ignoreRows bool) (viewable av.Viewable, attrView *av.AttributeView, err error) {
viewable, attrView, _, err = RenderAttributeViewWithTarget(blockID, avID, viewID, query, page, pageSize, groupPaging, "", createIfNotExist, ignoreRows, "", "")
return
}
// GetAttributeViewPasteRows 返回当前表格视图中从指定条目开始的连续行和可安全推断类型的空字段,供粘贴扩充行列。
func GetAttributeViewPasteRows(blockID, avID, viewID, groupID, query, startItemID string, count int) (
table *av.Table, inferableKeyIDs []string, err error,
) {
viewable, attrView, err := RenderAttributeView(blockID, avID, viewID, query, 1, math.MaxInt, nil, false, false)
if nil != err {
return nil, nil, err
}
table = av.TableFromViewable(viewable)
if nil == table {
return nil, nil, fmt.Errorf("attribute view [%s] is not a table", avID)
}
if "" != groupID {
var groupTable *av.Table
for _, group := range table.Groups {
if group.GetID() == groupID {
groupTable = av.TableFromViewable(group)
break
}
}
if nil == groupTable {
return nil, nil, fmt.Errorf("attribute view group [%s] not found", groupID)
}
table = groupTable
}
rows, err := getAttributeViewPasteRowsFromTable(table, startItemID, count)
if nil != err {
return nil, nil, err
}
table.Rows = rows
return table, getPasteInferableAttributeViewKeyIDs(attrView, getDependentRollupKeyIDs(attrView.ID)), nil
}
func getPasteInferableAttributeViewKeyIDs(attrView *av.AttributeView, dependentRollupKeyIDs map[string]struct{}) (ret []string) {
unsafeKeyIDs := dependentRollupKeyIDs
if nil == unsafeKeyIDs {
unsafeKeyIDs = map[string]struct{}{}
}
for _, itemTemplate := range attrView.NewItemTemplates {
if nil == itemTemplate {
continue
}
for keyID := range itemTemplate.FieldValues {
unsafeKeyIDs[keyID] = struct{}{}
}
}
for _, view := range attrView.Views {
if nil != view && nil != view.Group && "" != view.Group.Field {
unsafeKeyIDs[view.Group.Field] = struct{}{}
}
}
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
if _, unsafe := unsafeKeyIDs[keyValues.Key.ID]; unsafe {
continue
}
empty := true
for _, value := range keyValues.Values {
if !value.IsEmpty() {
empty = false
break
}
}
if empty {
ret = append(ret, keyValues.Key.ID)
}
}
return
}
func getDependentRollupKeyIDs(avID string) map[string]struct{} {
var relatedAttrViews []*av.AttributeView
for _, relatedAvID := range av.GetSrcAvIDs(avID) {
relatedAv, _ := av.ParseAttributeView(relatedAvID)
if nil == relatedAv {
continue
}
relatedAttrViews = append(relatedAttrViews, relatedAv)
}
return collectDependentRollupKeyIDs(relatedAttrViews)
}
func collectDependentRollupKeyIDs(attrViews []*av.AttributeView) (ret map[string]struct{}) {
ret = map[string]struct{}{}
for _, attrView := range attrViews {
if nil == attrView {
continue
}
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key || av.KeyTypeRollup != keyValues.Key.Type ||
nil == keyValues.Key.Rollup || "" == keyValues.Key.Rollup.KeyID {
continue
}
ret[keyValues.Key.Rollup.KeyID] = struct{}{}
}
}
return
}
func getAttributeViewPasteRowsFromTable(table *av.Table, startItemID string, count int) (rows []*av.TableRow, err error) {
if count < 1 {
return nil, fmt.Errorf("invalid paste row count [%d]", count)
}
start := -1
for i, row := range table.Rows {
if row.ID == startItemID {
start = i
break
}
}
if 0 > start {
return nil, fmt.Errorf("attribute view item [%s] not found", startItemID)
}
end := start + min(count, len(table.Rows)-start)
return table.Rows[start:end], nil
}
func RenderAttributeViewWithTarget(blockID, avID, viewID, query string, page, pageSize int, groupPaging map[string]any, initialLayout av.LayoutType, createIfNotExist, ignoreRows bool, targetItemID, targetGroupID string, calendarRanges ...*av.CalendarRange) (viewable av.Viewable, attrView *av.AttributeView, target *AttributeViewRenderTarget, err error) {
options := AttributeViewRenderOptions{}
if len(calendarRanges) > 0 {
options.CalendarRange = calendarRanges[0]
}
return RenderAttributeViewWithTargetOptions(blockID, avID, viewID, query, page, pageSize, groupPaging, initialLayout, createIfNotExist, ignoreRows, targetItemID, targetGroupID, options)
}
// RenderAttributeViewWithTargetReadOnly 仅在内存中渲染发布视图,不创建或保存数据库。
func RenderAttributeViewWithTargetReadOnly(blockID, avID, viewID, query string, page, pageSize int, groupPaging map[string]any, initialLayout av.LayoutType, createIfNotExist, ignoreRows bool, targetItemID, targetGroupID string, calendarRanges ...*av.CalendarRange) (viewable av.Viewable, attrView *av.AttributeView, target *AttributeViewRenderTarget, err error) {
options := AttributeViewRenderOptions{ReadOnly: true}
if len(calendarRanges) > 0 {
options.CalendarRange = calendarRanges[0]
}
return RenderAttributeViewWithTargetOptions(blockID, avID, viewID, query, page, pageSize, groupPaging, initialLayout, false, ignoreRows, targetItemID, targetGroupID, options)
}
// AttributeViewRenderOptions 仅影响本次渲染,不参与数据库持久化。
type AttributeViewRenderOptions struct {
ReadOnly bool
CalendarRange *av.CalendarRange
TemporarySort *av.ViewSort
}
// RenderAttributeViewWithTargetOptions 在分页前应用临时排序;临时排序和只读请求均不创建或保存数据库。
func RenderAttributeViewWithTargetOptions(blockID, avID, viewID, query string, page, pageSize int, groupPaging map[string]any, initialLayout av.LayoutType, createIfNotExist, ignoreRows bool, targetItemID, targetGroupID string, options AttributeViewRenderOptions) (viewable av.Viewable, attrView *av.AttributeView, target *AttributeViewRenderTarget, err error) {
timing := util.BeginPerformance("database.view")
defer timing.Finish()
writable := !options.ReadOnly && options.TemporarySort == nil
createIfNotExist = createIfNotExist && writable
if !ast.IsNodeIDPattern(avID) {
err = ErrInvalidID
return
}
if _, err = options.CalendarRange.Location(); nil != err {
return
}
timing.Stage("wait_sync")
waitForSyncingStorages()
timing.Stage("load")
avBoxID, exactBox, resolveErr := resolveAttributeViewCarrierBoxID(blockID)
if nil != resolveErr {
err = resolveErr
return
}
existPath, err := attributeViewRenderPath(avID, avBoxID, exactBox)
if nil != err {
return
}
if !filelock.IsExist(existPath) {
if !createIfNotExist {
err = av.ErrAttributeViewNotFound
return
}
if attrView, err = initializeAttributeViewForRender(blockID, avID, avBoxID, exactBox, initialLayout); nil != err {
logging.LogErrorf("initialize attribute view [%s] failed: %s", avID, err)
return
}
} else if exactBox {
attrView, err = av.ParseAttributeViewInBox(avID, avBoxID)
} else {
attrView, err = av.ParseAttributeView(avID)
}
if err != nil {
logging.LogErrorf("parse attribute view [%s] failed: %s", avID, err)
return
}
if temporarySort := options.TemporarySort; temporarySort != nil {
if temporarySort.Order != av.SortOrderAsc && temporarySort.Order != av.SortOrderDesc {
err = fmt.Errorf("invalid temporary sort order [%s]", temporarySort.Order)
return
}
view, viewErr := getRenderAttributeViewView(attrView, viewID, "", blockID, false)
if viewErr != nil {
err = viewErr
return
}
// 字段删除或不再支持排序时恢复已保存规则,避免阅读状态阻断数据库显示。
if key, keyErr := attrView.GetKey(temporarySort.Column); keyErr == nil && av.GetKeyCapability(key.Type).Sortable {
sort := *temporarySort
view.Sorts = []*av.ViewSort{&sort}
}
}
if targetItemID != "" {
target = &AttributeViewRenderTarget{Status: "itemNotFound", ItemID: targetItemID}
if nil != attrView.GetBlockValue(targetItemID) {
target.Status = "filtered"
}
}
timing.Stage("render")
viewable, err = renderAttributeView(attrView, blockID, viewID, "", query, page, pageSize, groupPaging, ignoreRows, writable, target, targetGroupID, options.CalendarRange)
return
}
func newAttributeViewWithLayout(avID string, initialLayout av.LayoutType) (ret *av.AttributeView) {
ret = av.NewAttributeView(avID)
switch initialLayout {
case av.LayoutTypeList, av.LayoutTypeCalendar, av.LayoutTypeGallery, av.LayoutTypeKanban:
default:
return
}
if err := changeAttrViewLayout(ret, ret.Views[0], initialLayout); err != nil {
return av.NewAttributeView(avID)
}
regenAttrViewGroups(ret)
return
}
const (
groupValueDefault = "_@default@_" // 默认分组值(值为空的默认分组)
groupValueNotInRange = "_@notInRange@_" // 不再范围内的分组值(只有数字类型的分组才可能是该值)
groupValueLast30Days, groupValueLast7Days = "_@last30Days@_", "_@last7Days@_"
groupValueYesterday, groupValueToday, groupValueTomorrow = "_@yesterday@_", "_@today@_", "_@tomorrow@_"
groupValueNext7Days, groupValueNext30Days = "_@next7Days@_", "_@next30Days@_"
)
func renderAttributeView(attrView *av.AttributeView, nodeID, viewID, carrierViewID, query string, page, pageSize int, groupPaging map[string]any, ignoreRows, writable bool, target *AttributeViewRenderTarget, targetGroupID string, calendarRanges ...*av.CalendarRange) (viewable av.Viewable, err error) {
timing := util.BeginPerformance("database.fields")
defer timing.Finish()
if err = attrView.ValidateLayouts(); nil != err {
return
}
// 获取待渲染的视图
view, err := getRenderAttributeViewView(attrView, viewID, carrierViewID, nodeID, writable)
if nil != err {
return
}
// 做一些数据兼容和订正处理
changed := checkAttrView(attrView, view)
changed = upgradeAttributeViewSpec(attrView) || changed
if !ignoreRows {
changed = normalizeAttributeViewBlockRefSubtypes(attrView) || changed
}
if writable && changed {
if err = av.SaveAttributeView(attrView); nil != err {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
filterContext, contextErr := resolveAttributeViewFilterContext(attrView, view, nodeID)
if nil != contextErr {
err = contextErr
return
}
// 渲染视图
renderContext := sql.NewAttributeViewRenderContext()
renderContext.ReadOnly = !writable
defer renderContext.PushTemplateErrors()
var orderReuse *attributeViewOrderReuse
if !ignoreRows && strings.TrimSpace(query) == "" && filterContext == nil && target == nil && targetGroupID == "" {
orderReuse = planAttributeViewOrderReuse(attrView, view, nodeID, writable)
if reused, found := orderReuse.renderPage(attrView, view, page, pageSize, renderContext); found {
timing.Count("order_cache_hit", 1)
return reused, nil
}
}
templatePlan := planAttributeViewTemplates(attrView, view, query, ignoreRows)
deferTemplateValues := templatePlan != nil
timing.Stage("fields")
if deferTemplateValues {
viewable = sql.RenderViewWithDeferredTemplatesContext(attrView, view, query, ignoreRows, renderContext)
timing.Count("required_templates", int64(len(templatePlan.required)))
timing.Count("deferred_templates", int64(len(templatePlan.deferred)))
sql.FillAttributeViewTemplateValuesForKeysWithContext(attrView, view, viewable.(av.Collection), templatePlan.required, renderContext)
} else {
viewable = sql.RenderViewWithContext(attrView, view, query, ignoreRows, renderContext)
}
if calendar, ok := viewable.(*av.Calendar); ok && len(calendarRanges) > 0 {
calendar.CalendarRange = calendarRanges[0]
}
var groupRenderSource *sql.GroupViewRenderSource
timing.Stage("rows_groups")
if !ignoreRows && view.IsGroupView() {
// 在父视图分页前保存完整条目索引,各分组复用已经生成的字段值。
groupRenderSource = sql.NewGroupViewRenderSource(viewable, query)
}
renderTargetItemID := targetItemID(target)
if view.IsGroupView() || view.LayoutType == av.LayoutTypeKanban {
renderTargetItemID = ""
}
var targetIndex, targetOffset int
targetIndex, targetOffset, err = renderViewableInstanceWithOrder(viewable, view, attrView, page, pageSize, ignoreRows,
renderTargetItemID, renderContext, orderReuse.capture, filterContext)
if nil != err {
return
}
if deferTemplateValues {
sql.FillAttributeViewTemplateValuesForKeysWithContext(attrView, view, viewable.(av.Collection), templatePlan.deferred, renderContext)
}
orderReuse.store(renderContext)
if nil != target && targetIndex >= 0 && !view.IsGroupView() && view.LayoutType != av.LayoutTypeKanban {
setAttributeViewRenderTarget(target, "", targetIndex, targetOffset, view.PageSize)
}
// 渲染分组视图。当 ignoreRows 时若有已生成的分组则渲染元数据供面板使用,无分组则跳过(生成分组需要行数据)
if view.LayoutType != av.LayoutTypeCalendar && (!ignoreRows || len(view.Groups) > 0) {
err = renderAttributeViewGroups(viewable, attrView, view, query, page, pageSize, groupPaging, groupRenderSource,
ignoreRows, writable, target, targetGroupID, renderContext, filterContext)
}
if writable && nil == err && attrView.HasCardCoverPositionChanges() {
if err = av.SaveAttributeView(attrView); nil != err {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
return
}
func renderAttributeViewGroups(viewable av.Viewable, attrView *av.AttributeView, view *av.View, query string, page,
pageSize int, groupPaging map[string]any, groupRenderSource *sql.GroupViewRenderSource, ignoreRows, writable bool,
target *AttributeViewRenderTarget, targetGroupID string, renderContext *sql.AttributeViewRenderContext,
filterContext *av.FilterContext) (err error) {
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
if view.LayoutType == av.LayoutTypeKanban {
preferredGroupKey := getKanbanPreferredGroupKey(attrView)
group := &av.ViewGroup{Field: preferredGroupKey.ID}
setAttributeViewGroup(attrView, view, group)
if writable {
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
groupKey = view.GetGroupKey(attrView)
if nil == groupKey {
return
}
} else {
return
}
}
// 当前日期可能会变,所以如果是按日期分组则需要重新生成分组。
// ignoreRows 时跳过重新生成(需要行数据),沿用已保存的分组。
if !ignoreRows && isGroupByDate(view) {
createdDate := time.UnixMilli(view.GroupCreated).Format("2006-01-02")
if time.Now().Format("2006-01-02") != createdDate {
genAttrViewGroupsFromRenderSource(view, attrView, groupRenderSource, query)
if writable {
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
}
}
// 如果是按模板分组则需要重新生成分组。
// ignoreRows 时跳过重新生成(需要行数据),沿用已保存的分组。
if !ignoreRows && isGroupByTemplate(attrView, view) {
genAttrViewGroupsFromRenderSource(view, attrView, groupRenderSource, query)
if writable {
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
}
// 渲染分组视图。ignoreRows 时若已存在分组则渲染元数据供面板使用,若无分组则返回(生成需要行数据)
if nil == view.Groups {
if ignoreRows {
return
}
genAttrViewGroupsFromRenderSource(view, attrView, groupRenderSource, query)
if writable {
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
}
for _, groupView := range view.Groups {
groupView.Name = groupView.GetGroupValue()
switch groupView.Name {
case groupValueDefault:
groupView.Name = fmt.Sprintf(Conf.language(264), groupKey.Name)
case groupValueNotInRange:
groupView.Name = Conf.language(265)
case groupValueLast30Days:
groupView.Name = fmt.Sprintf(Conf.language(259), 30)
case groupValueLast7Days:
groupView.Name = fmt.Sprintf(Conf.language(259), 7)
case groupValueYesterday:
groupView.Name = Conf.language(260)
case groupValueToday:
groupView.Name = Conf.language(261)
case groupValueTomorrow:
groupView.Name = Conf.language(262)
case groupValueNext7Days:
groupView.Name = fmt.Sprintf(Conf.language(263), 7)
case groupValueNext30Days:
groupView.Name = fmt.Sprintf(Conf.language(263), 30)
}
}
sortGroupViews(attrView, view)
targetGroupID = resolveAttributeViewTargetGroupID(view, target, targetGroupID)
var groups []av.Viewable
for _, groupView := range view.Groups {
groupViewable := sql.RenderGroupViewWithSourceContext(attrView, view, groupView, query, groupRenderSource,
ignoreRows, renderContext)
groupPage, groupPageSize := page, pageSize
if nil != groupPaging {
if paging := groupPaging[groupView.ID]; nil != paging {
pagingMap := paging.(map[string]any)
if nil != pagingMap["page"] {
groupPage = int(pagingMap["page"].(float64))
}
if nil != pagingMap["pageSize"] {
groupPageSize = int(pagingMap["pageSize"].(float64))
}
}
}
groupTargetItemID := ""
if nil != target {
if (targetGroupID != "" && groupView.ID == targetGroupID) || (targetGroupID == "" && target.Status != "visible") {
groupTargetItemID = target.ItemID
}
}
targetIndex, targetOffset, renderErr := renderViewableInstance(groupViewable, view, attrView, groupPage,
groupPageSize, ignoreRows, groupTargetItemID, renderContext, filterContext)
err = renderErr
if nil != err {
return
}
if !ignoreRows {
hideEmptyGroupViews(view, groupViewable)
}
if nil != target && targetIndex >= 0 {
if groupViewable.GetGroupHidden() == 0 {
if target.Status != "visible" || groupView.ID == targetGroupID {
setAttributeViewRenderTarget(target, groupView.ID, targetIndex, targetOffset, view.PageSize)
}
} else if target.Status != "visible" {
target.Status = "groupHidden"
target.GroupID = groupView.ID
}
}
groups = append(groups, groupViewable)
// 将分组视图的分组字段清空,减少冗余(字段信息可以在总的视图 view 对象上获取到)
switch groupView.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
groupView.GetTableLayout().Columns = nil
case av.LayoutTypeGallery:
groupView.Gallery.CardFields = nil
case av.LayoutTypeKanban:
groupView.Kanban.Fields = nil
}
}
viewable.SetGroups(groups)
// 将总的视图上的项目清空,减少冗余
viewable.(av.Collection).SetItems(nil)
return
}
func genAttrViewGroupsFromRenderSource(view *av.View, attrView *av.AttributeView,
source *sql.GroupViewRenderSource, query string) {
if nil != source && "" == strings.TrimSpace(query) {
genAttrViewGroupsWithItems(view, attrView, source.GetItems())
return
}
// 搜索结果中的条目不完整,重新生成分组时需绕过当前视图的过滤或分页缓存。
cached, hasCached := attrView.RenderedViewables[view.ID]
delete(attrView.RenderedViewables, view.ID)
genAttrViewGroups(view, attrView)
if hasCached {
attrView.RenderedViewables[view.ID] = cached
}
}
func hideEmptyGroupViews(view *av.View, viewable av.Viewable) {
if !view.IsGroupView() {
return
}
groupHidden := viewable.GetGroupHidden()
if 2 == groupHidden {
return
}
if !view.Group.HideEmpty {
viewable.SetGroupHidden(0)
return
}
itemCount := 0
switch viewable.GetType() {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
itemCount = av.TableFromViewable(viewable).RowCount
case av.LayoutTypeGallery:
itemCount = viewable.(*av.Gallery).CardCount
case av.LayoutTypeKanban:
itemCount = viewable.(*av.Kanban).CardCount
default:
itemCount = viewable.(av.Collection).CountItems()
}
if 1 > itemCount {
viewable.SetGroupHidden(1)
} else {
viewable.SetGroupHidden(0)
}
}
func sortGroupViews(attrView *av.AttributeView, view *av.View) {
if av.GroupOrderMan == view.Group.Order {
sort.Slice(view.Groups, func(i, j int) bool { return view.Groups[i].GroupSort < view.Groups[j].GroupSort })
return
}
if av.GroupMethodDateRelative == view.Group.Method {
var relativeDateGroups []*av.View
var last30Days, last7Days, yesterday, today, tomorrow, next7Days, next30Days, defaultGroup *av.View
for _, groupView := range view.Groups {
_, err := time.Parse("2006-01", groupView.GetGroupValue())
if nil == err { // 如果能解析出来说明是 30 天之前或 30 天之后的分组形式
relativeDateGroups = append(relativeDateGroups, groupView)
} else { // 否则是相对日期分组形式
switch groupView.GetGroupValue() {
case groupValueLast30Days:
last30Days = groupView
case groupValueLast7Days:
last7Days = groupView
case groupValueYesterday:
yesterday = groupView
case groupValueToday:
today = groupView
case groupValueTomorrow:
tomorrow = groupView
case groupValueNext7Days:
next7Days = groupView
case groupValueNext30Days:
next30Days = groupView
case groupValueDefault:
defaultGroup = groupView
}
}
}
sort.SliceStable(relativeDateGroups, func(i, j int) bool {
return relativeDateGroups[i].GetGroupValue() < relativeDateGroups[j].GetGroupValue()
})
var lastNext30Days []*av.View
if nil != next30Days {
lastNext30Days = append(lastNext30Days, next30Days)
}
if nil != next7Days {
lastNext30Days = append(lastNext30Days, next7Days)
}
if nil != tomorrow {
lastNext30Days = append(lastNext30Days, tomorrow)
}
if nil != today {
lastNext30Days = append(lastNext30Days, today)
}
if nil != yesterday {
lastNext30Days = append(lastNext30Days, yesterday)
}
if nil != last7Days {
lastNext30Days = append(lastNext30Days, last7Days)
}
if nil != last30Days {
lastNext30Days = append(lastNext30Days, last30Days)
}
startIdx := -1
todayStart := util.GetTodayStart()
thisMonth := todayStart.Format("2006-01")
for i, monthGroup := range relativeDateGroups {
if monthGroup.GetGroupValue() < thisMonth {
startIdx = i + 1
}
}
if -1 == startIdx {
startIdx = 0
}
for _, g := range lastNext30Days {
relativeDateGroups = slices.Insert(relativeDateGroups, startIdx, g)
}
if av.GroupOrderDesc == view.Group.Order {
slices.Reverse(relativeDateGroups)
}
if nil != defaultGroup {
relativeDateGroups = append(relativeDateGroups, defaultGroup)
}
view.Groups = relativeDateGroups
return
}
if av.GroupOrderAsc == view.Group.Order || av.GroupOrderDesc == view.Group.Order {
defaultGroup := view.GetGroupByGroupValue(groupValueDefault)
if nil != defaultGroup {
view.RemoveGroupByID(defaultGroup.ID)
}
sort.SliceStable(view.Groups, func(i, j int) bool {
iVal, jVal := view.Groups[i].GetGroupValue(), view.Groups[j].GetGroupValue()
if av.GroupOrderAsc == view.Group.Order {
return util.NaturalCompare(iVal, jVal)
}
return util.NaturalCompare(jVal, iVal)
})
if nil != defaultGroup {
view.Groups = append(view.Groups, defaultGroup)
}
return
}
if av.GroupOrderSelectOption == view.Group.Order {
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
return
}
if av.KeyTypeSelect != groupKey.Type && av.KeyTypeMSelect != groupKey.Type {
return
}
sortGroupsBySelectOption(view, groupKey)
return
}
}
func sortGroupsBySelectOption(view *av.View, groupKey *av.Key) {
optionSort := map[string]int{}
for i, op := range groupKey.Options {
optionSort[op.Name] = i
}
defaultGroup := view.GetGroupByGroupValue(groupValueDefault)
if nil != defaultGroup {
view.RemoveGroupByID(defaultGroup.ID)
}
sort.Slice(view.Groups, func(i, j int) bool {
vSort := optionSort[view.Groups[i].GetGroupValue()]
oSort := optionSort[view.Groups[j].GetGroupValue()]
return vSort < oSort
})
if nil != defaultGroup {
view.Groups = append(view.Groups, defaultGroup)
}
}
func isGroupByDate(view *av.View) bool {
if !view.IsGroupView() {
return false
}
return av.GroupMethodDateDay == view.Group.Method || av.GroupMethodDateWeek == view.Group.Method || av.GroupMethodDateMonth == view.Group.Method || av.GroupMethodDateYear == view.Group.Method || av.GroupMethodDateRelative == view.Group.Method
}
func isGroupByTemplate(attrView *av.AttributeView, view *av.View) bool {
if !view.IsGroupView() {
return false
}
if av.ValueSourceRendered == view.Group.ValueSource {
return true
}
groupKey := view.GetGroupKey(attrView)
if nil == groupKey {
return false
}
return av.KeyTypeTemplate == groupKey.Type
}
func shouldDeferAttributeViewTemplateValues(attrView *av.AttributeView, view *av.View, query string,
ignoreRows bool) bool {
if nil == attrView || nil == view || ignoreRows || "" != strings.TrimSpace(query) || view.IsGroupView() ||
av.LayoutTypeKanban == view.LayoutType {
return false
}
templateKeyIDs := map[string]bool{}
renderTemplateKeyIDs := map[string]bool{}
for _, keyValues := range attrView.KeyValues {
if nil == keyValues || nil == keyValues.Key {
continue
}
if av.KeyTypeTemplate == keyValues.Key.Type {
templateKeyIDs[keyValues.Key.ID] = true
} else if "" != strings.TrimSpace(keyValues.Key.RenderTemplate) {
renderTemplateKeyIDs[keyValues.Key.ID] = true
}
}
if 0 == len(templateKeyIDs) && 0 == len(renderTemplateKeyIDs) {
return false
}
// 日历日期模板参与区间筛选和定位,必须在筛选条目之前完成计算。
if view.LayoutType == av.LayoutTypeCalendar && view.Calendar != nil &&
renderTemplateKeyIDs[view.Calendar.Settings.DateKeyID] {
return false
}
for _, rule := range view.EffectiveConditionalColors() {
if nil != rule && nil != rule.Filter && (templateKeyIDs[rule.Filter.Column] ||
(renderTemplateKeyIDs[rule.Filter.Column] && rule.Filter.ValueSource == av.ValueSourceRendered)) {
return false
}
}
for keyID := range templateKeyIDs {
if attrViewFiltersContainColumn(view.Filters, keyID) {
return false
}
}
if attrViewFiltersUseRenderedValues(view.Filters, renderTemplateKeyIDs) {
return false
}
for _, viewSort := range view.Sorts {
if nil != viewSort && (templateKeyIDs[viewSort.Column] ||
(renderTemplateKeyIDs[viewSort.Column] && av.ValueSourceRendered == viewSort.ValueSource)) {
return false
}
}
if nil != view.GroupCalc && templateKeyIDs[view.GroupCalc.Field] {
return false
}
hasTemplateField := false
checkField := func(fieldID string, calc *av.FieldCalc) bool {
if !templateKeyIDs[fieldID] && !renderTemplateKeyIDs[fieldID] {
return false
}
hasTemplateField = true
return templateKeyIDs[fieldID] && nil != calc && av.CalcOperatorNone != calc.Operator
}
switch view.LayoutType {
case av.LayoutTypeTable, av.LayoutTypeList, av.LayoutTypeCalendar:
for _, column := range view.GetTableLayout().Columns {
if nil != column && nil != column.BaseField && checkField(column.ID, column.Calc) {
return false
}
}
case av.LayoutTypeGallery:
for _, field := range view.Gallery.CardFields {
if nil != field && nil != field.BaseField && checkField(field.ID, field.Calc) {
return false
}
}
}
return hasTemplateField
}
func attrViewFiltersUseRenderedValues(filters []*av.ViewFilter, renderTemplateKeyIDs map[string]bool) bool {
for _, filter := range filters {
if nil == filter {
continue
}
if filter.IsGroup() {
if attrViewFiltersUseRenderedValues(filter.Filters, renderTemplateKeyIDs) {
return true
}
continue
}
if renderTemplateKeyIDs[filter.Column] && av.ValueSourceRendered == filter.ValueSource {
return true
}
}
return false
}
func renderViewableInstance(viewable av.Viewable, view *av.View, attrView *av.AttributeView, page, pageSize int,
ignoreRows bool, targetItemID string,
renderContext *sql.AttributeViewRenderContext, filterContexts ...*av.FilterContext) (targetIndex, targetOffset int, err error) {
return renderViewableInstanceWithOrder(viewable, view, attrView, page, pageSize, ignoreRows, targetItemID, renderContext, nil, filterContexts...)
}
func renderViewableInstanceWithOrder(viewable av.Viewable, view *av.View, attrView *av.AttributeView, page, pageSize int,
ignoreRows bool, targetItemID string, renderContext *sql.AttributeViewRenderContext, captureOrder func([]av.Item),
filterContexts ...*av.FilterContext) (targetIndex, targetOffset int, err error) {
timing := util.BeginPerformance("database.rows")
defer timing.Finish()
timing.Count("page_size", int64(pageSize))
targetIndex = -1
if nil == viewable {
err = av.ErrViewNotFound
logging.LogErrorf("render attribute view [%s] failed", attrView.ID)
return
}
// ignoreRows 时行已为空,跳过 filter/sort/calc 和分页(菜单不需要行数据)
if ignoreRows {
return
}
if timing != nil {
if collection, ok := viewable.(av.Collection); ok {
timing.Count("rows_before", int64(collection.CountItems()))
}
}
cachedAttrViews := map[string]*av.AttributeView{}
rollupFurtherCollections := sql.GetFurtherCollectionsWithContext(attrView, cachedAttrViews, renderContext)
var filterContext *av.FilterContext
if 0 < len(filterContexts) {
filterContext = filterContexts[0]
}
timing.Stage("filter")
av.FilterWithContext(viewable, attrView, rollupFurtherCollections, cachedAttrViews, filterContext)
if timing != nil {
if collection, ok := viewable.(av.Collection); ok {
timing.Count("rows_filtered", int64(collection.CountItems()))
}
}
timing.Stage("sort")
av.Sort(viewable, attrView)
timing.Stage("calculate")
av.Calc(viewable, attrView)
if captureOrder != nil {
captureOrder(viewable.(av.Collection).GetItems())
}
timing.Stage("paginate")
// 日历按可见范围读取,不使用普通条目分页。
switch viewable.GetType() {
case av.LayoutTypeCalendar:
calendar := viewable.(*av.Calendar)
if err = av.FilterCalendarRows(calendar, calendar.CalendarRange, targetItemID); nil != err {
return
}
targetIndex = findAttributeViewTargetIndex(targetItemID, len(calendar.Rows), func(index int) string { return calendar.Rows[index].ID })
case av.LayoutTypeTable, av.LayoutTypeList:
table := av.TableFromViewable(viewable)
targetIndex = findAttributeViewTargetIndex(targetItemID, len(table.Rows), func(index int) string { return table.Rows[index].ID })
table.RowCount = len(table.Rows)
table.PageSize = view.PageSize
if 1 > pageSize {
pageSize = table.PageSize
}
start, end := getAttributeViewRenderRange(page, pageSize, targetIndex, table.PageSize, len(table.Rows))
if targetIndex >= 0 {
targetOffset = start
}
table.Rows = table.Rows[start:end]
case av.LayoutTypeGallery:
gallery := viewable.(*av.Gallery)
targetIndex = findAttributeViewTargetIndex(targetItemID, len(gallery.Cards), func(index int) string { return gallery.Cards[index].ID })
gallery.CardCount = len(gallery.Cards)
gallery.PageSize = view.PageSize
if 1 > pageSize {
pageSize = gallery.PageSize
}
start, end := getAttributeViewRenderRange(page, pageSize, targetIndex, gallery.PageSize, len(gallery.Cards))
if targetIndex >= 0 {
targetOffset = start
}
gallery.Cards = gallery.Cards[start:end]
case av.LayoutTypeKanban:
kanban := viewable.(*av.Kanban)
targetIndex = findAttributeViewTargetIndex(targetItemID, len(kanban.Cards), func(index int) string { return kanban.Cards[index].ID })
kanban.CardCount = len(kanban.Cards)
kanban.PageSize = view.PageSize
if 1 > pageSize {
pageSize = kanban.PageSize
}
start, end := getAttributeViewRenderRange(page, pageSize, targetIndex, kanban.PageSize, len(kanban.Cards))
if targetIndex >= 0 {
targetOffset = start
}
kanban.Cards = kanban.Cards[start:end]
}
timing.Stage("colors")
if timing != nil {
if collection, ok := viewable.(av.Collection); ok {
timing.Count("rows_page", int64(collection.CountItems()))
}
}
av.RenderConditionalColors(viewable, view, attrView, rollupFurtherCollections, cachedAttrViews)
return
}
func targetItemID(target *AttributeViewRenderTarget) string {
if nil == target {
return ""
}
return target.ItemID
}
func findAttributeViewTargetIndex(targetItemID string, length int, getID func(index int) string) int {
if targetItemID == "" {
return -1
}
for i := range length {
if getID(i) == targetItemID {
return i
}
}
return -1
}
func getAttributeViewRenderRange(page, pageSize, targetIndex, defaultPageSize, length int) (start, end int) {
if 1 > defaultPageSize {
defaultPageSize = av.ViewDefaultPageSize
}
if 1 > pageSize {
pageSize = defaultPageSize
}
if targetIndex < 0 {
start = min(length, max(0, (page-1)*pageSize))
end = min(length, start+pageSize)
return
}
windowSize := min(length, max(defaultPageSize, av.ViewDefaultPageSize*4))
start = max(0, targetIndex-windowSize/2)
end = min(length, start+windowSize)
start = max(0, end-windowSize)
return
}
func resolveAttributeViewTargetGroupID(view *av.View, target *AttributeViewRenderTarget, targetGroupID string) string {
if targetGroupID == "" || nil == target {
return targetGroupID
}
targetGroup := view.GetGroupByID(targetGroupID)
if nil == targetGroup || !gulu.Str.Contains(target.ItemID, targetGroup.GroupItemIDs) {
return ""
}
return targetGroupID
}
func setAttributeViewRenderTarget(target *AttributeViewRenderTarget, groupID string, index, offset, pageSize int) {
target.Status = "visible"
target.GroupID = groupID
target.Index = index
target.Offset = offset
target.PageSize = pageSize
}
func getRenderAttributeViewView(attrView *av.AttributeView, viewID, carrierViewID, nodeID string, writable bool) (ret *av.View, err error) {
if _, firstViewErr := attrView.GetFirstView(); nil != firstViewErr {
view, _, _ := av.NewTableViewWithBlockKey(ast.NewNodeID())
attrView.Views = append(attrView.Views, view)
if writable {
if err = av.SaveAttributeView(attrView); err != nil {
logging.LogErrorf("save attribute view [%s] failed: %s", attrView.ID, err)
return
}
}
}
return resolveAttributeViewView(attrView, viewID, carrierViewID, nodeID)
}
// avBoxIDFromRepoPath 从快照文件路径反查 boxID。
// 全局路径 /storage/av/<avID>.json 返回空串;加密笔记本路径 /<boxID>/storage/av/<avID>.json 返回 boxID。
func avBoxIDFromRepoPath(repoPath string) string {
parts := strings.Split(repoPath, "/")
// 全局路径: ["", "storage", "av", "xxx.json"] → parts[1]=="storage"
// 加密 box: ["", "<boxID>", "storage", "av", "xxx.json"] → parts[1]=="<boxID>"
if len(parts) >= 4 && parts[2] == "storage" {
return parts[1]
}
return ""
}
// ResolveRepoSnapshotAttributeViewBoxID 返回快照属性视图的唯一加密笔记本上下文。
func ResolveRepoSnapshotAttributeViewBoxID(indexID, avID string) (string, error) {
if !ast.IsNodeIDPattern(avID) {
return "", ErrInvalidID
}
repo, err := newRepository()
if err != nil {
return "", err
}
index, err := repo.GetIndex(indexID)
if err != nil {
return "", err
}
files, err := repo.GetFiles(index)
if err != nil {
return "", err
}
var matches []*entity.File
for _, file := range files {
if strings.HasSuffix(file.Path, "/storage/av/"+avID+".json") {
matches = append(matches, file)
}
}
if len(matches) == 0 {
return "", av.ErrAttributeViewNotFound
}
if len(matches) != 1 {
return "", fmt.Errorf("attribute view snapshot context is ambiguous [%s]", avID)
}
boxID := avBoxIDFromRepoPath(matches[0].Path)
if IsEncryptedBox(boxID) {
return boxID, nil
}
return "", nil
}
// ResolveHistoryAttributeViewBoxID 返回历史属性视图的唯一加密笔记本上下文。
func ResolveHistoryAttributeViewBoxID(avID, created string) (string, error) {
if !ast.IsNodeIDPattern(avID) {
return "", ErrInvalidID
}
createdUnix, err := strconv.ParseInt(created, 10, 64)
if err != nil {
return "", fmt.Errorf("parse created [%s] failed: %w", created, err)
}
dirPrefix := time.Unix(createdUnix, 0).Format("2006-01-02-150405")
matches, err := filepath.Glob(filepath.Join(util.HistoryDir, dirPrefix+"*"))
if err != nil {
return "", err
}
var boxIDs []string
for _, historyDir := range matches {
if gulu.File.IsExist(filepath.Join(historyDir, "storage", "av", avID+".json")) {
boxIDs = append(boxIDs, "")
}
entries, _ := os.ReadDir(historyDir)
for _, entry := range entries {
if !entry.IsDir() || !ast.IsNodeIDPattern(entry.Name()) {
continue
}
candidate := filepath.Join(historyDir, entry.Name(), "storage", "av", avID+".json")
if gulu.File.IsExist(candidate) {
boxIDs = append(boxIDs, entry.Name())
}
}
}
if len(boxIDs) == 0 {
return "", av.ErrAttributeViewNotFound
}
if len(boxIDs) != 1 {
return "", fmt.Errorf("attribute view history context is ambiguous [%s]", avID)
}
if IsEncryptedBox(boxIDs[0]) {
return boxIDs[0], nil
}
return "", nil
}
func loadHistoryWorkspacePalette(historyDir string) (
ret []*av.AttributeViewCustomColor, order []string, found bool,
) {
path := filepath.Join(historyDir, "storage", "inline-styles.json")
if !gulu.File.IsExist(path) {
return nil, nil, false
}
data, err := os.ReadFile(path)
if nil != err {
logging.LogWarnf("read historical inline styles failed: %s", err)
return nil, nil, false
}
return decodeHistoricalWorkspacePalette(data)
}
func decodeHistoricalWorkspacePalette(data []byte) (
ret []*av.AttributeViewCustomColor, order []string, found bool,
) {
var styles struct {
AV *struct {
Colors []*av.AttributeViewCustomColor `json:"colors"`
Order []string `json:"order"`
} `json:"av"`
}
if err := gulu.JSON.UnmarshalJSON(data, &styles); nil != err || nil == styles.AV {
return nil, nil, false
}
colors, err := av.NormalizeAttributeViewCustomColors(styles.AV.Colors, false)
if nil != err {
return nil, nil, false
}
return colors, av.NormalizeAttributeViewColorOrder(styles.AV.Order, colors), true
}
func newAttributeViewCustomColorRenderContext(colors []*av.AttributeViewCustomColor, order []string,
found bool) *av.CustomColorRenderContext {
colors, _ = av.NormalizeAttributeViewCustomColors(colors, false)
order = av.NormalizeAttributeViewColorOrder(order, colors)
return &av.CustomColorRenderContext{ResolveRelatedCustomColors: func(string) (
retColors []*av.AttributeViewCustomColor, retOrder []string, retFound bool,
) {
retColors, _ = av.NormalizeAttributeViewCustomColors(colors, false)
retOrder = av.NormalizeAttributeViewColorOrder(order, retColors)
return retColors, retOrder, found
}}
}
func newHistoryAttributeViewCustomColorRenderContext(historyDir string) *av.CustomColorRenderContext {
colors, order, found := loadHistoryWorkspacePalette(historyDir)
return newAttributeViewCustomColorRenderContext(colors, order, found)
}
func RenderRepoSnapshotAttributeView(indexID, avID, viewID, carrierViewID string, calendarRanges ...*av.CalendarRange) (viewable av.Viewable, attrView *av.AttributeView, err error) {
if !ast.IsNodeIDPattern(avID) {
err = ErrInvalidID
return
}
repo, err := newRepository()
if err != nil {
return
}
index, err := repo.GetIndex(indexID)
if err != nil {
return
}
files, err := repo.GetFiles(index)
if err != nil {
return
}
var avFiles []*entity.File
for _, f := range files {
// 匹配全局 /storage/av/<avID>.json 或加密笔记本/<boxID>/storage/av/<avID>.json
if strings.HasSuffix(f.Path, "/storage/av/"+avID+".json") {
avFiles = append(avFiles, f)
}
}
if len(avFiles) == 0 {
attrView = av.NewAttributeView(avID)
err = av.ErrAttributeViewNotFound
return
}
if len(avFiles) != 1 {
err = fmt.Errorf("attribute view snapshot context is ambiguous [%s]", avID)
return
}
avFile := avFiles[0]
data, readErr := repo.OpenFile(avFile)
if nil != readErr {
logging.LogErrorf("read attribute view [%s] failed: %s", avID, readErr)
err = readErr
return
}
data, err = decryptHistoricalAttributeView(avBoxIDFromRepoPath(avFile.Path), avID, data)
if err != nil {
logging.LogErrorf("decrypt snapshot attribute view [%s] failed: %s", avID, err)
return
}
attrView, err = parseHistoricalAttributeViewData(avID, data)
if nil != err {
return
}
var snapshotColors []*av.AttributeViewCustomColor
var snapshotOrder []string
var snapshotPaletteFound bool
for _, file := range files {
if !isInlineStylesRepoPath(file.Path) {
continue
}
inlineStylesData, openErr := repo.OpenFile(file)
if openErr != nil {
logging.LogWarnf("read snapshot inline styles failed: %s", openErr)
break
}
snapshotColors, snapshotOrder, snapshotPaletteFound = decodeHistoricalWorkspacePalette(inlineStylesData)
break
}
attrView.CustomColorRenderContext = newAttributeViewCustomColorRenderContext(
snapshotColors, snapshotOrder, snapshotPaletteFound)
attrView.ResolveDirectColors()
viewable, err = renderAttributeView(attrView, "", viewID, carrierViewID, "", 1, -1, nil, false, false, nil, "", calendarRanges...)
return
}
func RenderHistoryAttributeView(avID, viewID, carrierViewID, query string, page, pageSize int, groupPaging map[string]any, created string, calendarRanges ...*av.CalendarRange) (viewable av.Viewable, attrView *av.AttributeView, err error) {
if !ast.IsNodeIDPattern(avID) {
err = ErrInvalidID
return
}
createdUnix, parseErr := strconv.ParseInt(created, 10, 64)
if nil != parseErr {
logging.LogErrorf("parse created [%s] failed: %s", created, parseErr)
err = fmt.Errorf("parse created [%s] failed: %w", created, parseErr)
return
}
dirPrefix := time.Unix(createdUnix, 0).Format("2006-01-02-150405")
globPath := filepath.Join(util.HistoryDir, dirPrefix+"*")
matches, err := filepath.Glob(globPath)
if err != nil {
logging.LogErrorf("glob [%s] failed: %s", globPath, err)
return
}
if 1 > len(matches) {
err = av.ErrAttributeViewNotFound
return
}
type historyAttributeViewSource struct {
path string
boxID string
historyDir string
}
var sources []historyAttributeViewSource
for _, historyDir := range matches {
globalPath := filepath.Join(historyDir, "storage", "av", avID+".json")
if gulu.File.IsExist(globalPath) {
sources = append(sources, historyAttributeViewSource{path: globalPath, historyDir: historyDir})
}
entries, _ := os.ReadDir(historyDir)
for _, entry := range entries {
if entry.IsDir() && ast.IsNodeIDPattern(entry.Name()) {
candidate := filepath.Join(historyDir, entry.Name(), "storage", "av", avID+".json")
if gulu.File.IsExist(candidate) {
sources = append(sources, historyAttributeViewSource{
path: candidate, boxID: entry.Name(), historyDir: historyDir,
})
}
}
}
}
if len(sources) == 0 {
attrView = av.NewAttributeView(avID)
err = av.ErrAttributeViewNotFound
return
}
if len(sources) != 1 {
err = fmt.Errorf("attribute view history context is ambiguous [%s]", avID)
return
}
source := sources[0]
data, readErr := os.ReadFile(source.path)
if nil != readErr {
logging.LogErrorf("read attribute view [%s] failed: %s", avID, readErr)
err = readErr
return
}
data, err = decryptHistoricalAttributeView(source.boxID, avID, data)
if err != nil {
logging.LogErrorf("decrypt history attribute view [%s] failed: %s", avID, err)
return
}
attrView, err = parseHistoricalAttributeViewData(avID, data)
if nil != err {
return
}
attrView.CustomColorRenderContext = newHistoryAttributeViewCustomColorRenderContext(source.historyDir)
attrView.ResolveDirectColors()
viewable, err = renderAttributeView(attrView, "", viewID, carrierViewID, query, page, pageSize, groupPaging, false, false, nil, "", calendarRanges...)
return
}
// 历史和仓库快照完成认证后共用字段校验,不重写历史源数据。
func parseHistoricalAttributeViewData(avID string, data []byte) (*av.AttributeView, error) {
view := av.NewAttributeView(avID)
if err := gulu.JSON.UnmarshalJSON(data, view); nil != err {
return nil, err
}
if err := av.CheckSpec(view); nil != err {
return nil, err
}
if err := view.ValidateLayouts(); nil != err {
return nil, err
}
if err := view.NormalizeLocations(); nil != err {
return nil, err
}
return view, nil
}
func decryptHistoricalAttributeView(boxID, avID string, data []byte) ([]byte, error) {
ciphertext := util.IsCiphertext(data)
if boxID == "" {
if ciphertext {
return nil, errors.New("encrypted attribute view snapshot is missing notebook context")
}
return data, nil
}
if !IsEncryptedBox(boxID) {
if ciphertext {
return nil, fmt.Errorf("encrypted attribute view snapshot has no matching notebook [%s]", boxID)
}
return data, nil
}
if !ciphertext {
return nil, fmt.Errorf("encrypted notebook attribute view snapshot is plaintext [%s]", boxID)
}
return av.DecryptAVData(boxID, avID, data)
}