Skip to content

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

7.4 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 sql

import (
	"github.com/88250/lute"
	"github.com/88250/lute/ast"
	"github.com/88250/lute/parse"
	"github.com/siyuan-note/siyuan/kernel/av"
	"github.com/siyuan-note/siyuan/kernel/filesys"
	"github.com/siyuan-note/siyuan/kernel/treenode"
	"github.com/siyuan-note/siyuan/kernel/util"
)

func renderAttributeViewKanban(attrView *av.AttributeView, view *av.View, query string, depth *int,
	cachedAttrViews map[string]*av.AttributeView, ignoreRows, deferTemplateValues bool,
	renderContext *AttributeViewRenderContext) (ret *av.Kanban) {
	if !ignoreRows && !deferTemplateValues {
		viewable := attrView.RenderedViewables[view.ID]
		if nil != viewable {
			ret = viewable.(*av.Kanban)
			return
		}
	}

	ret = &av.Kanban{
		BaseInstance:           av.NewViewBaseInstance(view),
		CoverFrom:              view.Kanban.CoverFrom,
		CoverFromAssetKeyID:    view.Kanban.CoverFromAssetKeyID,
		CardAspectRatio:        view.Kanban.CardAspectRatio,
		CardAspectRatioValue:   view.Kanban.CardAspectRatioValue,
		CardSize:               view.Kanban.CardSize,
		CardWidth:              view.Kanban.CardWidth,
		CardLayout:             view.Kanban.CardLayout,
		FitImage:               view.Kanban.FitImage,
		DisplayFieldName:       view.Kanban.DisplayFieldName,
		DisplayEmptyFields:     view.Kanban.DisplayEmptyFields,
		FillColBackgroundColor: view.Kanban.FillColBackgroundColor,
		Fields:                 []*av.KanbanField{},
		Cards:                  []*av.KanbanCard{},
	}

	// 组装字段
	for _, field := range view.Kanban.Fields {
		key, getErr := attrView.GetKey(field.ID)
		if nil != getErr {
			// 找不到字段则在视图中删除(元数据查询场景不写盘)
			if !ignoreRows {
				removeMissingField(attrView, view, field.ID, renderContext)
			}
			continue
		}

		ret.Fields = append(ret.Fields, &av.KanbanField{
			BaseInstanceField: &av.BaseInstanceField{
				ID:             key.ID,
				Name:           key.Name,
				Type:           key.Type,
				Icon:           key.Icon,
				Wrap:           field.Wrap,
				Hidden:         field.Hidden,
				Desc:           key.Desc,
				Calc:           field.Calc,
				Options:        key.Options,
				NumberFormat:   key.NumberFormat,
				DateFormat:     key.DateFormat,
				Template:       key.Template,
				RenderTemplate: key.RenderTemplate,
				Relation:       key.Relation,
				Rollup:         key.Rollup,
				Date:           key.Date,
				Created:        key.Created,
				Updated:        key.Updated,
			},
			FullRow: field.FullRow,
		})
	}

	// 菜单等只需要字段/视图元数据的场景,跳过全部卡片处理
	if ignoreRows {
		return
	}

	cardsValues := generateAttrViewItems(attrView, view) // 生成卡片
	filterNotFoundAttrViewItems(cardsValues)             // 过滤掉不存在的卡片

	// 批量加载绑定块对应的树
	var ialIDs []string
	for _, keyValues := range cardsValues {
		for _, kValues := range keyValues {
			blockVal := kValues.GetBlockValue()
			if nil != blockVal && !blockVal.IsDetached {
				ialIDs = append(ialIDs, blockVal.Block.ID)
			}
		}
	}
	boundTrees := filesys.LoadTrees(ialIDs)

	// 生成卡片字段值
	for cardID, cardValues := range cardsValues {
		// 按字段 ID 建索引,避免后续字段循环里对每个字段做线性查找
		kvByField := map[string]*av.KeyValues{}
		for _, keyValues := range cardValues {
			if _, ok := kvByField[keyValues.Key.ID]; !ok { // 同一字段存在多个值时只取第一个
				kvByField[keyValues.Key.ID] = keyValues
			}
		}

		var kanbanCard av.KanbanCard
		for _, field := range ret.Fields {
			var fieldValue *av.KanbanFieldValue
			if keyValues, ok := kvByField[field.ID]; ok {
				fieldValue = &av.KanbanFieldValue{
					BaseValue: &av.BaseValue{
						ID:        keyValues.Values[0].ID,
						Value:     keyValues.Values[0],
						ValueType: field.Type,
					},
				}
			}
			if nil == fieldValue {
				fieldValue = &av.KanbanFieldValue{
					BaseValue: &av.BaseValue{
						ID:        cardID[:14] + ast.NewNodeID()[14:],
						ValueType: field.Type,
					},
				}
			}
			kanbanCard.ID = cardID

			filedDateIsTime := false
			if nil != field.Date {
				filedDateIsTime = field.Date.FillSpecificTime
			}
			fillAttributeViewBaseValue(fieldValue.BaseValue, field.ID, cardID, field.NumberFormat, field.DateFormat,
				field.Template, filedDateIsTime)
			kanbanCard.Values = append(kanbanCard.Values, fieldValue)
		}

		fillAttributeViewKanbanCardCover(attrView, view, cardValues, &kanbanCard, cardID, luteEngine, boundTrees)
		kanbanCard.CoverPosition = attrView.GetCardCoverPosition(cardID,
			av.CardCoverSource(view.Kanban.CoverFrom, view.Kanban.CoverFromAssetKeyID), kanbanCard.CoverURL)
		ret.Cards = append(ret.Cards, &kanbanCard)
	}

	// 回填补全数据
	fillAttributeViewKeyValues(attrView, ret)

	// 批量获取块属性以提升性能
	ials := BatchGetBlockAttrsWitTrees(ialIDs, boundTrees)

	// 渲染自动生成的字段值,比如关联、汇总、创建时间和更新时间
	fillAttributeViewAutoGeneratedValues(attrView, ret, ials, depth, cachedAttrViews, renderContext)

	if !deferTemplateValues {
		// 最后渲染模板字段,这样模板就可以使用汇总、关联、创建时间和更新时间的值了
		fillAttributeViewTemplateValues(attrView, view, ret, ials, renderContext)
	}

	filterByQuery(query, ret)
	manualSort(view, ret)
	return
}

func fillAttributeViewKanbanCardCover(attrView *av.AttributeView, view *av.View, cardValues []*av.KeyValues, kanbanCard *av.KanbanCard, cardID string, luteEngine *lute.Lute, trees map[string]*parse.Tree) {
	switch view.Kanban.CoverFrom {
	case av.CoverFromNone:
	case av.CoverFromContentImage:
		blockValue := getBlockValue(cardValues)
		if blockValue.IsDetached {
			break
		}

		tree := trees[blockValue.Block.ID]
		if nil == tree {
			break
		}
		node := treenode.GetNodeInTree(tree, blockValue.Block.ID)
		if nil == node {
			break
		}

		if ast.NodeDocument == node.Type {
			if titleImg := treenode.GetDocTitleImgPath(node); "" != titleImg {
				kanbanCard.CoverURL = titleImg
				break
			}

			if titleImgCSS := node.IALAttr("title-img"); "" != titleImgCSS {
				kanbanCard.CoverURL = titleImgCSS
				break
			}
		}

		ast.Walk(node, func(n *ast.Node, entering bool) ast.WalkStatus {
			if !entering {
				return ast.WalkContinue
			}

			if ast.NodeImage != n.Type {
				return ast.WalkContinue
			}

			dest := n.ChildByType(ast.NodeLinkDest)
			if nil == dest {
				return ast.WalkContinue
			}
			kanbanCard.CoverURL = dest.TokensStr()
			return ast.WalkStop
		})

		if "" == kanbanCard.CoverURL {
			kanbanCard.CoverContent = renderCoverContentBlock(node, luteEngine)
			return
		}
	case av.CoverFromAssetField:
		if "" == view.Kanban.CoverFromAssetKeyID {
			break
		}

		assetValue := attrView.GetValue(view.Kanban.CoverFromAssetKeyID, cardID)
		if nil == assetValue || 1 > len(assetValue.MAsset) {
			break
		}

		for _, asset := range assetValue.MAsset {
			if asset.Type == av.AssetTypeImage && util.IsPossiblyImage(asset.Content) {
				kanbanCard.CoverURL = asset.Content
				break
			}
		}
		return
	case av.CoverFromContentBlock:
		blockValue := getBlockValue(cardValues)
		if blockValue.IsDetached {
			break
		}

		tree := trees[blockValue.Block.ID]
		if nil == tree {
			break
		}
		node := treenode.GetNodeInTree(tree, blockValue.Block.ID)
		if nil == node {
			break
		}
		kanbanCard.CoverContent = renderCoverContentBlock(node, luteEngine)
	}
}