✨ Database kanban view https://github.com/siyuan-note/siyuan/issues/8873

Signed-off-by: Daniel <845765@qq.com>

kernel/av/layout_kanban.go

@@ -56,15 +56,24 @@ type ViewKanbanField struct {
 type Kanban struct {
 	*BaseInstance
 
-	Fields    []*KanbanField `json:"fields"`   // 卡片字段
-	Cards     []*KanbanCard  `json:"cards"`    // 卡片
-	CardCount int            `json:"rowCount"` // 总卡片数
+	CoverFrom           CoverFrom       `json:"coverFrom"`                     // 封面来源
+	CoverFromAssetKeyID string          `json:"coverFromAssetKeyID,omitempty"` // 资源字段 ID，CoverFrom 为 CoverFromAssetField 时有效
+	CardAspectRatio     CardAspectRatio `json:"cardAspectRatio"`               // 卡片宽高比
+	CardSize            CardSize        `json:"cardSize"`                      // 卡片大小
+	FitImage            bool            `json:"fitImage"`                      // 是否适应封面图片大小
+	DisplayFieldName    bool            `json:"displayFieldName"`              // 是否显示字段名称
+	Fields              []*KanbanField  `json:"fields"`                        // 卡片字段
+	Cards               []*KanbanCard   `json:"cards"`                         // 卡片
+	CardCount           int             `json:"rowCount"`                      // 总卡片数
 }
 
 // KanbanCard 描述了看板实例卡片的结构。
 type KanbanCard struct {
 	ID     string              `json:"id"`     // 卡片 ID
 	Values []*KanbanFieldValue `json:"values"` // 卡片字段值
+
+	CoverURL     string `json:"coverURL"`     // 卡片封面超链接
+	CoverContent string `json:"coverContent"` // 卡片封面文本内容
 }
 
 // KanbanField 描述了看板实例字段的结构。

kernel/model/attribute_view.go

@@ -429,7 +429,7 @@ func syncAttrViewTableColWidth(operation *Operation) (err error) {
 				break
 			}
 		}
-	case av.LayoutTypeGallery:
+	case av.LayoutTypeGallery, av.LayoutTypeKanban:
 		return
 	}
 
@@ -846,6 +846,11 @@ func setAttrViewWrapField(operation *Operation) (err error) {
 		for _, field := range view.Gallery.CardFields {
 			field.Wrap = allFieldWrap
 		}
+	case av.LayoutTypeKanban:
+		view.Kanban.WrapField = allFieldWrap
+		for _, field := range view.Kanban.Fields {
+			field.Wrap = allFieldWrap
+		}
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -876,6 +881,8 @@ func setAttrViewShowIcon(operation *Operation) (err error) {
 		view.Table.ShowIcon = operation.Data.(bool)
 	case av.LayoutTypeGallery:
 		view.Gallery.ShowIcon = operation.Data.(bool)
+	case av.LayoutTypeKanban:
+		view.Kanban.ShowIcon = operation.Data.(bool)
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -1002,6 +1009,8 @@ func setAttrViewCoverFromAssetKeyID(operation *Operation) (err error) {
 		return
 	case av.LayoutTypeGallery:
 		view.Gallery.CoverFromAssetKeyID = operation.KeyID
+	case av.LayoutTypeKanban:
+		view.Kanban.CoverFromAssetKeyID = operation.KeyID
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -1955,6 +1964,9 @@ func genAttrViewGroups(view *av.View, attrView *av.AttributeView) {
 		case av.LayoutTypeGallery:
 			v = av.NewGalleryView()
 			v.Gallery = av.NewLayoutGallery()
+		case av.LayoutTypeKanban:
+			v = av.NewKanbanView()
+			v.Kanban = av.NewLayoutKanban()
 		default:
 			logging.LogWarnf("unknown layout type [%s] for group view", view.LayoutType)
 			return
@@ -2351,6 +2363,8 @@ func updateAttributeViewColRelation(operation *Operation) (err error) {
 				v.Table.Columns = append(v.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: operation.BackRelationKeyID}})
 			case av.LayoutTypeGallery:
 				v.Gallery.CardFields = append(v.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: operation.BackRelationKeyID}})
+			case av.LayoutTypeKanban:
+				v.Kanban.Fields = append(v.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: operation.BackRelationKeyID}})
 			}
 		}
 
@@ -2566,6 +2580,8 @@ func (tx *Transaction) doDuplicateAttrViewView(operation *Operation) (ret *TxErr
 		view = av.NewTableView()
 	case av.LayoutTypeGallery:
 		view = av.NewGalleryView()
+	case av.LayoutTypeKanban:
+		view = av.NewKanbanView()
 	}
 
 	view.ID = operation.ID
@@ -2718,6 +2734,10 @@ func addAttrViewView(avID, viewID, blockID string, layout av.LayoutType) (err er
 			for _, field := range firstView.Gallery.CardFields {
 				view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
 			}
+		case av.LayoutTypeKanban:
+			for _, field := range firstView.Kanban.Fields {
+				view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
+			}
 		}
 	case av.LayoutTypeGallery:
 		view = av.NewGalleryView()
@@ -2730,6 +2750,22 @@ func addAttrViewView(avID, viewID, blockID string, layout av.LayoutType) (err er
 			for _, field := range firstView.Gallery.CardFields {
 				view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: field.ID}})
 			}
+		case av.LayoutTypeKanban:
+			for _, field := range firstView.Kanban.Fields {
+				view.Gallery.CardFields = append(view.Gallery.CardFields, &av.ViewGalleryCardField{BaseField: &av.BaseField{ID: field.ID}})
+			}
+		}
+	case av.LayoutTypeKanban:
+		view = av.NewKanbanView()
+		switch firstView.LayoutType {
+		case av.LayoutTypeTable:
+			for _, col := range firstView.Table.Columns {
+				view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: col.ID}})
+			}
+		case av.LayoutTypeKanban:
+			for _, field := range firstView.Kanban.Fields {
+				view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: &av.BaseField{ID: field.ID}})
+			}
 		}
 	default:
 		err = av.ErrWrongLayoutType
@@ -3058,7 +3094,7 @@ func setAttributeViewColumnCalc(operation *Operation) (err error) {
 				break
 			}
 		}
-	case av.LayoutTypeGallery:
+	case av.LayoutTypeGallery, av.LayoutTypeKanban:
 		return
 	}
 
@@ -3558,6 +3594,22 @@ func duplicateAttributeViewKey(operation *Operation) (err error) {
 					break
 				}
 			}
+		case av.LayoutTypeKanban:
+			for i, field := range view.Kanban.Fields {
+				if field.ID == key.ID {
+					view.Kanban.Fields = append(view.Kanban.Fields[:i+1], append([]*av.ViewKanbanField{
+						{
+							BaseField: &av.BaseField{
+								ID:     copyKey.ID,
+								Wrap:   field.Wrap,
+								Hidden: field.Hidden,
+								Desc:   field.Desc,
+							},
+						},
+					}, view.Kanban.Fields[i+1:]...)...)
+					break
+				}
+			}
 		}
 	}
 
@@ -3592,7 +3644,7 @@ func setAttributeViewColWidth(operation *Operation) (err error) {
 				break
 			}
 		}
-	case av.LayoutTypeGallery:
+	case av.LayoutTypeGallery, av.LayoutTypeKanban:
 		return
 	}
 
@@ -3638,6 +3690,14 @@ func setAttributeViewColWrap(operation *Operation) (err error) {
 			allFieldWrap = allFieldWrap && field.Wrap
 		}
 		view.Gallery.WrapField = allFieldWrap
+	case av.LayoutTypeKanban:
+		for _, field := range view.Kanban.Fields {
+			if field.ID == operation.ID {
+				field.Wrap = newWrap
+			}
+			allFieldWrap = allFieldWrap && field.Wrap
+		}
+		view.Kanban.WrapField = allFieldWrap
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -3678,6 +3738,13 @@ func setAttributeViewColHidden(operation *Operation) (err error) {
 				break
 			}
 		}
+	case av.LayoutTypeKanban:
+		for _, field := range view.Kanban.Fields {
+			if field.ID == operation.ID {
+				field.Hidden = operation.Data.(bool)
+				break
+			}
+		}
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -3711,7 +3778,7 @@ func setAttributeViewColPin(operation *Operation) (err error) {
 				break
 			}
 		}
-	case av.LayoutTypeGallery:
+	case av.LayoutTypeGallery, av.LayoutTypeKanban:
 		return
 	}
 
@@ -3939,6 +4006,27 @@ func SortAttributeViewViewKey(avID, blockID, keyID, previousKeyID string) (err e
 			}
 		}
 		view.Gallery.CardFields = util.InsertElem(view.Gallery.CardFields, previousIndex, field)
+	case av.LayoutTypeKanban:
+		var field *av.ViewKanbanField
+		for i, kanbanField := range view.Kanban.Fields {
+			if kanbanField.ID == keyID {
+				field = kanbanField
+				curIndex = i
+				break
+			}
+		}
+		if nil == field {
+			return
+		}
+
+		view.Kanban.Fields = append(view.Kanban.Fields[:curIndex], view.Kanban.Fields[curIndex+1:]...)
+		for i, kanbanField := range view.Kanban.Fields {
+			if kanbanField.ID == previousKeyID {
+				previousIndex = i + 1
+				break
+			}
+		}
+		view.Kanban.Fields = util.InsertElem(view.Kanban.Fields, previousIndex, field)
 	}
 
 	err = av.SaveAttributeView(attrView)
@@ -4062,8 +4150,8 @@ func AddAttributeViewKey(avID, keyID, keyName, keyType, keyIcon, previousKeyID s
 				newField.Wrap = view.Table.WrapField
 
 				if "" == previousKeyID {
-					if av.LayoutTypeGallery == currentView.LayoutType {
-						// 如果当前视图是卡片视图则添加到最后
+					if av.LayoutTypeGallery == currentView.LayoutType || av.LayoutTypeKanban == currentView.LayoutType {
+						// 如果当前视图是卡片或看板视图则添加到最后
 						view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: newField})
 					} else {
 						view.Table.Columns = append([]*av.ViewTableColumn{{BaseField: newField}}, view.Table.Columns...)
@@ -4102,6 +4190,26 @@ func AddAttributeViewKey(avID, keyID, keyName, keyType, keyIcon, previousKeyID s
 					}
 				}
 			}
+
+			if nil != view.Kanban {
+				newField.Wrap = view.Kanban.WrapField
+
+				if "" == previousKeyID {
+					view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
+				} else {
+					added := false
+					for i, field := range view.Kanban.Fields {
+						if field.ID == previousKeyID {
+							view.Kanban.Fields = append(view.Kanban.Fields[:i+1], append([]*av.ViewKanbanField{{BaseField: newField}}, view.Kanban.Fields[i+1:]...)...)
+							added = true
+							break
+						}
+					}
+					if !added {
+						view.Kanban.Fields = append(view.Kanban.Fields, &av.ViewKanbanField{BaseField: newField})
+					}
+				}
+			}
 		}
 	}
 
@@ -4314,6 +4422,13 @@ func RemoveAttributeViewKey(avID, keyID string, removeRelationDest bool) (err er
 									break
 								}
 							}
+						case av.LayoutTypeKanban:
+							for i, field := range view.Kanban.Fields {
+								if field.ID == removedKey.Relation.BackKeyID {
+									view.Kanban.Fields = append(view.Kanban.Fields[:i], view.Kanban.Fields[i+1:]...)
+									break
+								}
+							}
 						}
 					}
 				}
@@ -4358,6 +4473,15 @@ func RemoveAttributeViewKey(avID, keyID string, removeRelationDest bool) (err er
 				}
 			}
 		}
+
+		if nil != view.Kanban {
+			for i, field := range view.Kanban.Fields {
+				if field.ID == keyID {
+					view.Kanban.Fields = append(view.Kanban.Fields[:i], view.Kanban.Fields[i+1:]...)
+					break
+				}
+			}
+		}
 	}
 
 	for _, view := range attrView.Views {

kernel/model/attribute_view_render.go

@@ -167,6 +167,8 @@ func renderAttributeViewGroups(viewable av.Viewable, attrView *av.AttributeView,
 			groupView.Table.Columns = nil
 		case av.LayoutTypeGallery:
 			groupView.Gallery.CardFields = nil
+		case av.LayoutTypeKanban:
+			groupView.Kanban.Fields = nil
 		}
 	}
 	viewable.SetGroups(groups)
@@ -402,6 +404,19 @@ func renderViewableInstance(viewable av.Viewable, view *av.View, attrView *av.At
 			end = len(gallery.Cards)
 		}
 		gallery.Cards = gallery.Cards[start:end]
+	case av.LayoutTypeKanban:
+		kanban := viewable.(*av.Kanban)
+		kanban.CardCount = 0
+		kanban.PageSize = view.PageSize
+		if 1 > pageSize {
+			pageSize = kanban.PageSize
+		}
+		start := (page - 1) * pageSize
+		end := start + pageSize
+		if len(kanban.Cards) < end {
+			end = len(kanban.Cards)
+		}
+		kanban.Cards = kanban.Cards[start:end]
 	}
 	return
 }

kernel/model/export.go

@@ -3454,6 +3454,11 @@ func getAttrViewTable(attrView *av.AttributeView, view *av.View, query string) (
 		for _, field := range view.Gallery.CardFields {
 			view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
 		}
+	case av.LayoutTypeKanban:
+		view.Table = av.NewLayoutTable()
+		for _, field := range view.Kanban.Fields {
+			view.Table.Columns = append(view.Table.Columns, &av.ViewTableColumn{BaseField: &av.BaseField{ID: field.ID}})
+		}
 	}
 
 	depth := 1

kernel/sql/av.go

@@ -72,6 +72,8 @@ func RenderGroupView(attrView *av.AttributeView, view, groupView *av.View, query
 			groupView.Table.Columns = view.Table.Columns
 		case av.LayoutTypeGallery:
 			groupView.Gallery.CardFields = view.Gallery.CardFields
+		case av.LayoutTypeKanban:
+			groupView.Kanban.Fields = view.Kanban.Fields
 		}
 	}
 
@@ -102,6 +104,8 @@ func renderView(attrView *av.AttributeView, view *av.View, query string, depth *
 		ret = RenderAttributeViewTable(attrView, view, query, depth, cachedAttrViews)
 	case av.LayoutTypeGallery:
 		ret = RenderAttributeViewGallery(attrView, view, query, depth, cachedAttrViews)
+	case av.LayoutTypeKanban:
+		ret = RenderAttributeViewKanban(attrView, view, query, depth, cachedAttrViews)
 	}
 	return
 }
@@ -784,6 +788,16 @@ func removeMissingField(attrView *av.AttributeView, view *av.View, missingKeyID
 		}
 	}
 
+	if nil != view.Kanban {
+		for i, kanbanField := range view.Kanban.Fields {
+			if kanbanField.ID == missingKeyID {
+				view.Kanban.Fields = append(view.Kanban.Fields[:i], view.Kanban.Fields[i+1:]...)
+				changed = true
+				break
+			}
+		}
+	}
+
 	if changed {
 		av.SaveAttributeView(attrView)
 	}

kernel/sql/av_kanban.go

@@ -0,0 +1,219 @@
+package sql
+
+import (
+	"fmt"
+
+	"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) (ret *av.Kanban) {
+	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,
+		CardSize:            view.Kanban.CardSize,
+		FitImage:            view.Kanban.FitImage,
+		DisplayFieldName:    view.Kanban.DisplayFieldName,
+		Fields:              []*av.KanbanField{},
+		Cards:               []*av.KanbanCard{},
+	}
+
+	// 组装字段
+	for _, field := range view.Kanban.Fields {
+		key, getErr := attrView.GetKey(field.ID)
+		if nil != getErr {
+			// 找不到字段则在视图中删除
+			removeMissingField(attrView, view, field.ID)
+			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,
+				Template:     key.Template,
+				Relation:     key.Relation,
+				Rollup:       key.Rollup,
+				Date:         key.Date,
+			},
+		})
+	}
+
+	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 {
+		var kanbanCard av.KanbanCard
+		for _, field := range ret.Fields {
+			var fieldValue *av.KanbanFieldValue
+			for _, keyValues := range cardValues {
+				if keyValues.Key.ID == field.ID {
+					fieldValue = &av.KanbanFieldValue{
+						BaseValue: &av.BaseValue{
+							ID:        keyValues.Values[0].ID,
+							Value:     keyValues.Values[0],
+							ValueType: field.Type,
+						},
+					}
+					break
+				}
+			}
+			if nil == fieldValue {
+				fieldValue = &av.KanbanFieldValue{
+					BaseValue: &av.BaseValue{
+						ID:        cardID[:14] + ast.NewNodeID()[14:],
+						ValueType: field.Type,
+					},
+				}
+			}
+			kanbanCard.ID = cardID
+
+			filedDateAutoFill := false
+			if nil != field.Date {
+				filedDateAutoFill = field.Date.AutoFillNow
+			}
+			fillAttributeViewBaseValue(fieldValue.BaseValue, field.ID, cardID, field.NumberFormat, field.Template, filedDateAutoFill)
+			kanbanCard.Values = append(kanbanCard.Values, fieldValue)
+		}
+
+		fillAttributeViewKanbanCardCover(attrView, view, cardValues, &kanbanCard, cardID, luteEngine, boundTrees)
+		ret.Cards = append(ret.Cards, &kanbanCard)
+	}
+
+	// 回填补全数据
+	fillAttributeViewKeyValues(attrView, ret)
+
+	// 批量获取块属性以提升性能
+	ials := BatchGetBlockAttrsWitTrees(ialIDs, boundTrees)
+
+	// 渲染自动生成的字段值，比如关联、汇总、创建时间和更新时间
+	fillAttributeViewAutoGeneratedValues(attrView, ret, ials, depth, cachedAttrViews)
+
+	// 最后渲染模板字段，这样模板就可以使用汇总、关联、创建时间和更新时间的值了
+	renderTemplateErr := fillAttributeViewTemplateValues(attrView, view, ret, ials)
+	if nil != renderTemplateErr {
+		util.PushErrMsg(fmt.Sprintf(util.Langs[util.Lang][44], util.EscapeHTML(renderTemplateErr.Error())), 30000)
+	}
+
+	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
+		}
+
+		p := assetValue.MAsset[0].Content
+		if util.IsAssetsImage(p) {
+			kanbanCard.CoverURL = p
+		}
+		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)
+	}
+}