mirror of
https://github.com/siyuan-note/siyuan.git
synced 2025-12-17 15:10:12 +01:00
473 lines
15 KiB
Go
473 lines
15 KiB
Go
package sql
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/88250/lute"
|
|
"github.com/88250/lute/ast"
|
|
"github.com/88250/lute/parse"
|
|
"github.com/88250/lute/render"
|
|
"github.com/siyuan-note/siyuan/kernel/av"
|
|
"github.com/siyuan-note/siyuan/kernel/treenode"
|
|
"github.com/siyuan-note/siyuan/kernel/util"
|
|
)
|
|
|
|
func RenderAttributeViewGallery(attrView *av.AttributeView, view *av.View, query string) (ret *av.Gallery) {
|
|
ret = &av.Gallery{
|
|
BaseInstance: &av.BaseInstance{
|
|
ID: view.ID,
|
|
Icon: view.Icon,
|
|
Name: view.Name,
|
|
Desc: view.Desc,
|
|
HideAttrViewName: view.HideAttrViewName,
|
|
Filters: view.Gallery.Filters,
|
|
Sorts: view.Gallery.Sorts,
|
|
},
|
|
Fields: []*av.GalleryField{},
|
|
Cards: []*av.GalleryCard{},
|
|
}
|
|
|
|
// 组装字段
|
|
for _, field := range view.Gallery.CardFields {
|
|
key, getErr := attrView.GetKey(field.ID)
|
|
if nil != getErr {
|
|
// 找不到字段则在视图中删除
|
|
removeMissingField(attrView, view, field.ID)
|
|
continue
|
|
}
|
|
|
|
ret.Fields = append(ret.Fields, &av.GalleryField{
|
|
BaseInstanceField: &av.BaseInstanceField{
|
|
ID: key.ID,
|
|
Name: key.Name,
|
|
Type: key.Type,
|
|
Icon: key.Icon,
|
|
Hidden: field.Hidden,
|
|
Desc: key.Desc,
|
|
Options: key.Options,
|
|
NumberFormat: key.NumberFormat,
|
|
Template: key.Template,
|
|
Relation: key.Relation,
|
|
Rollup: key.Rollup,
|
|
Date: key.Date,
|
|
},
|
|
})
|
|
}
|
|
|
|
// 生成卡片
|
|
cardsValues := map[string][]*av.KeyValues{}
|
|
for _, keyValues := range attrView.KeyValues {
|
|
for _, val := range keyValues.Values {
|
|
values := cardsValues[val.BlockID]
|
|
if nil == values {
|
|
values = []*av.KeyValues{{Key: keyValues.Key, Values: []*av.Value{val}}}
|
|
} else {
|
|
values = append(values, &av.KeyValues{Key: keyValues.Key, Values: []*av.Value{val}})
|
|
}
|
|
cardsValues[val.BlockID] = values
|
|
}
|
|
}
|
|
|
|
// 过滤掉不存在的卡片
|
|
var notFound []string
|
|
var toCheckBlockIDs []string
|
|
for blockID, keyValues := range cardsValues {
|
|
blockValue := getBlockValue(keyValues)
|
|
if nil == blockValue {
|
|
notFound = append(notFound, blockID)
|
|
continue
|
|
}
|
|
|
|
if blockValue.IsDetached {
|
|
continue
|
|
}
|
|
|
|
if nil != blockValue.Block && "" == blockValue.Block.ID {
|
|
notFound = append(notFound, blockID)
|
|
continue
|
|
}
|
|
|
|
toCheckBlockIDs = append(toCheckBlockIDs, blockID)
|
|
}
|
|
checkRet := treenode.ExistBlockTrees(toCheckBlockIDs)
|
|
for blockID, exist := range checkRet {
|
|
if !exist {
|
|
notFound = append(notFound, blockID)
|
|
}
|
|
}
|
|
for _, blockID := range notFound {
|
|
delete(cardsValues, blockID)
|
|
}
|
|
|
|
// 生成卡片字段值
|
|
for cardID, cardValues := range cardsValues {
|
|
var galleryCard av.GalleryCard
|
|
for _, field := range ret.Fields {
|
|
var fieldValue *av.GalleryFieldValue
|
|
for _, keyValues := range cardValues {
|
|
if keyValues.Key.ID == field.ID {
|
|
fieldValue = &av.GalleryFieldValue{
|
|
BaseValue: &av.BaseValue{
|
|
ID: keyValues.Values[0].ID,
|
|
Value: keyValues.Values[0],
|
|
ValueType: field.Type,
|
|
},
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if nil == fieldValue {
|
|
fieldValue = &av.GalleryFieldValue{
|
|
BaseValue: &av.BaseValue{
|
|
ID: ast.NewNodeID(),
|
|
ValueType: field.Type,
|
|
},
|
|
}
|
|
}
|
|
galleryCard.ID = cardID
|
|
|
|
switch fieldValue.ValueType {
|
|
case av.KeyTypeNumber: // 格式化数字
|
|
if nil != fieldValue.Value && nil != fieldValue.Value.Number && fieldValue.Value.Number.IsNotEmpty {
|
|
fieldValue.Value.Number.Format = field.NumberFormat
|
|
fieldValue.Value.Number.FormatNumber()
|
|
}
|
|
case av.KeyTypeTemplate: // 渲染模板字段
|
|
fieldValue.Value = &av.Value{ID: fieldValue.ID, KeyID: field.ID, BlockID: cardID, Type: av.KeyTypeTemplate, Template: &av.ValueTemplate{Content: field.Template}}
|
|
case av.KeyTypeCreated: // 填充创建时间字段值，后面再渲染
|
|
fieldValue.Value = &av.Value{ID: fieldValue.ID, KeyID: field.ID, BlockID: cardID, Type: av.KeyTypeCreated}
|
|
case av.KeyTypeUpdated: // 填充更新时间字段值，后面再渲染
|
|
fieldValue.Value = &av.Value{ID: fieldValue.ID, KeyID: field.ID, BlockID: cardID, Type: av.KeyTypeUpdated}
|
|
case av.KeyTypeRelation: // 清空关联字段值，后面再渲染 https://ld246.com/article/1703831044435
|
|
if nil != fieldValue.Value && nil != fieldValue.Value.Relation {
|
|
fieldValue.Value.Relation.Contents = nil
|
|
}
|
|
}
|
|
|
|
if nil == fieldValue.Value {
|
|
fieldValue.Value = av.GetAttributeViewDefaultValue(fieldValue.ID, field.ID, cardID, fieldValue.ValueType)
|
|
} else {
|
|
fillAttributeViewNilValue(fieldValue.Value, fieldValue.ValueType)
|
|
}
|
|
|
|
galleryCard.Values = append(galleryCard.Values, fieldValue)
|
|
}
|
|
|
|
fillGalleryCardCover(attrView, view, cardValues, galleryCard, cardID, luteEngine)
|
|
ret.Cards = append(ret.Cards, &galleryCard)
|
|
}
|
|
|
|
// 批量获取块属性以提升性能
|
|
var ialIDs []string
|
|
for _, card := range ret.Cards {
|
|
block := card.GetBlockValue()
|
|
if nil != block && !block.IsDetached {
|
|
ialIDs = append(ialIDs, card.ID)
|
|
}
|
|
}
|
|
ials := BatchGetBlockAttrs(ialIDs)
|
|
|
|
// 渲染自动生成的字段值，比如关联字段、汇总字段、创建时间字段和更新时间字段
|
|
avCache := map[string]*av.AttributeView{}
|
|
avCache[attrView.ID] = attrView
|
|
for _, card := range ret.Cards {
|
|
for _, value := range card.Values {
|
|
switch value.ValueType {
|
|
case av.KeyTypeBlock: // 对于主键可能需要填充静态锚文本 Database-bound block primary key supports setting static anchor text https://github.com/siyuan-note/siyuan/issues/10049
|
|
if nil != value.Value.Block {
|
|
for k, v := range ials[card.ID] {
|
|
if k == av.NodeAttrViewStaticText+"-"+attrView.ID {
|
|
value.Value.Block.Content = v
|
|
break
|
|
}
|
|
}
|
|
}
|
|
case av.KeyTypeRollup: // 渲染汇总字段
|
|
rollupKey, _ := attrView.GetKey(value.Value.KeyID)
|
|
if nil == rollupKey || nil == rollupKey.Rollup {
|
|
break
|
|
}
|
|
|
|
relKey, _ := attrView.GetKey(rollupKey.Rollup.RelationKeyID)
|
|
if nil == relKey || nil == relKey.Relation {
|
|
break
|
|
}
|
|
|
|
relVal := attrView.GetValue(relKey.ID, card.ID)
|
|
if nil == relVal || nil == relVal.Relation {
|
|
break
|
|
}
|
|
|
|
destAv := avCache[relKey.Relation.AvID]
|
|
if nil == destAv {
|
|
destAv, _ = av.ParseAttributeView(relKey.Relation.AvID)
|
|
if nil != destAv {
|
|
avCache[relKey.Relation.AvID] = destAv
|
|
}
|
|
}
|
|
if nil == destAv {
|
|
break
|
|
}
|
|
|
|
destKey, _ := destAv.GetKey(rollupKey.Rollup.KeyID)
|
|
if nil == destKey {
|
|
continue
|
|
}
|
|
|
|
for _, blockID := range relVal.Relation.BlockIDs {
|
|
destVal := destAv.GetValue(rollupKey.Rollup.KeyID, blockID)
|
|
if nil == destVal {
|
|
if destAv.ExistBlock(blockID) { // 数据库中存在但是值不存在是数据未初始化，这里补一个默认值
|
|
destVal = av.GetAttributeViewDefaultValue(ast.NewNodeID(), rollupKey.Rollup.KeyID, blockID, destKey.Type)
|
|
}
|
|
if nil == destVal {
|
|
continue
|
|
}
|
|
}
|
|
if av.KeyTypeNumber == destKey.Type {
|
|
destVal.Number.Format = destKey.NumberFormat
|
|
destVal.Number.FormatNumber()
|
|
}
|
|
|
|
value.Value.Rollup.Contents = append(value.Value.Rollup.Contents, destVal.Clone())
|
|
}
|
|
|
|
value.Value.Rollup.RenderContents(rollupKey.Rollup.Calc, destKey)
|
|
|
|
// 将汇总字段的值保存到 cardsValues 中，后续渲染模板字段的时候会用到，下同
|
|
keyValues := cardsValues[card.ID]
|
|
keyValues = append(keyValues, &av.KeyValues{Key: rollupKey, Values: []*av.Value{{ID: value.Value.ID, KeyID: rollupKey.ID, BlockID: card.ID, Type: av.KeyTypeRollup, Rollup: value.Value.Rollup}}})
|
|
cardsValues[card.ID] = keyValues
|
|
case av.KeyTypeRelation: // 渲染关联字段
|
|
relKey, _ := attrView.GetKey(value.Value.KeyID)
|
|
if nil != relKey && nil != relKey.Relation {
|
|
destAv := avCache[relKey.Relation.AvID]
|
|
if nil == destAv {
|
|
destAv, _ = av.ParseAttributeView(relKey.Relation.AvID)
|
|
if nil != destAv {
|
|
avCache[relKey.Relation.AvID] = destAv
|
|
}
|
|
}
|
|
if nil != destAv {
|
|
blocks := map[string]*av.Value{}
|
|
blockValues := destAv.GetBlockKeyValues()
|
|
if nil != blockValues {
|
|
for _, blockValue := range blockValues.Values {
|
|
blocks[blockValue.BlockID] = blockValue
|
|
}
|
|
for _, blockID := range value.Value.Relation.BlockIDs {
|
|
if val := blocks[blockID]; nil != val {
|
|
value.Value.Relation.Contents = append(value.Value.Relation.Contents, val)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
keyValues := cardsValues[card.ID]
|
|
keyValues = append(keyValues, &av.KeyValues{Key: relKey, Values: []*av.Value{{ID: value.Value.ID, KeyID: relKey.ID, BlockID: card.ID, Type: av.KeyTypeRelation, Relation: value.Value.Relation}}})
|
|
cardsValues[card.ID] = keyValues
|
|
case av.KeyTypeCreated: // 渲染创建时间
|
|
createdStr := card.ID[:len("20060102150405")]
|
|
created, parseErr := time.ParseInLocation("20060102150405", createdStr, time.Local)
|
|
if nil == parseErr {
|
|
value.Value.Created = av.NewFormattedValueCreated(created.UnixMilli(), 0, av.CreatedFormatNone)
|
|
value.Value.Created.IsNotEmpty = true
|
|
} else {
|
|
value.Value.Created = av.NewFormattedValueCreated(time.Now().UnixMilli(), 0, av.CreatedFormatNone)
|
|
}
|
|
|
|
keyValues := cardsValues[card.ID]
|
|
createdKey, _ := attrView.GetKey(value.Value.KeyID)
|
|
keyValues = append(keyValues, &av.KeyValues{Key: createdKey, Values: []*av.Value{{ID: value.Value.ID, KeyID: createdKey.ID, BlockID: card.ID, Type: av.KeyTypeCreated, Created: value.Value.Created}}})
|
|
cardsValues[card.ID] = keyValues
|
|
case av.KeyTypeUpdated: // 渲染更新时间
|
|
ial := ials[card.ID]
|
|
if nil == ial {
|
|
ial = map[string]string{}
|
|
}
|
|
block := card.GetBlockValue()
|
|
updatedStr := ial["updated"]
|
|
if "" == updatedStr && nil != block {
|
|
value.Value.Updated = av.NewFormattedValueUpdated(block.Block.Updated, 0, av.UpdatedFormatNone)
|
|
value.Value.Updated.IsNotEmpty = true
|
|
} else {
|
|
updated, parseErr := time.ParseInLocation("20060102150405", updatedStr, time.Local)
|
|
if nil == parseErr {
|
|
value.Value.Updated = av.NewFormattedValueUpdated(updated.UnixMilli(), 0, av.UpdatedFormatNone)
|
|
value.Value.Updated.IsNotEmpty = true
|
|
} else {
|
|
value.Value.Updated = av.NewFormattedValueUpdated(time.Now().UnixMilli(), 0, av.UpdatedFormatNone)
|
|
}
|
|
}
|
|
|
|
keyValues := cardsValues[card.ID]
|
|
updatedKey, _ := attrView.GetKey(value.Value.KeyID)
|
|
keyValues = append(keyValues, &av.KeyValues{Key: updatedKey, Values: []*av.Value{{ID: value.Value.ID, KeyID: updatedKey.ID, BlockID: card.ID, Type: av.KeyTypeUpdated, Updated: value.Value.Updated}}})
|
|
cardsValues[card.ID] = keyValues
|
|
}
|
|
}
|
|
}
|
|
|
|
// 最后单独渲染模板字段，这样模板字段就可以使用汇总、关联、创建时间和更新时间字段的值了
|
|
|
|
var renderTemplateErr error
|
|
for _, card := range ret.Cards {
|
|
for _, value := range card.Values {
|
|
switch value.ValueType {
|
|
case av.KeyTypeTemplate: // 渲染模板字段
|
|
keyValues := cardsValues[card.ID]
|
|
ial := ials[card.ID]
|
|
if nil == ial {
|
|
ial = map[string]string{}
|
|
}
|
|
content, renderErr := RenderTemplateField(ial, keyValues, value.Value.Template.Content)
|
|
value.Value.Template.Content = content
|
|
if nil != renderErr {
|
|
key, _ := attrView.GetKey(value.Value.KeyID)
|
|
keyName := ""
|
|
if nil != key {
|
|
keyName = key.Name
|
|
}
|
|
renderTemplateErr = fmt.Errorf("database [%s] template field [%s] rendering failed: %s", getAttrViewName(attrView), keyName, renderErr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if nil != renderTemplateErr {
|
|
util.PushErrMsg(fmt.Sprintf(util.Langs[util.Lang][44], util.EscapeHTML(renderTemplateErr.Error())), 30000)
|
|
}
|
|
|
|
// 根据搜索条件过滤
|
|
query = strings.TrimSpace(query)
|
|
if "" != query {
|
|
// 将连续空格转换为一个空格
|
|
query = strings.Join(strings.Fields(query), " ")
|
|
// 按空格分割关键字
|
|
keywords := strings.Split(query, " ")
|
|
// 使用 AND 逻辑 https://github.com/siyuan-note/siyuan/issues/11535
|
|
var hitCards []*av.GalleryCard
|
|
for _, card := range ret.Cards {
|
|
hit := false
|
|
for _, value := range card.Values {
|
|
allKeywordsHit := true
|
|
for _, keyword := range keywords {
|
|
if !strings.Contains(strings.ToLower(value.Value.String(true)), strings.ToLower(keyword)) {
|
|
allKeywordsHit = false
|
|
break
|
|
}
|
|
}
|
|
if allKeywordsHit {
|
|
hit = true
|
|
break
|
|
}
|
|
}
|
|
if hit {
|
|
hitCards = append(hitCards, card)
|
|
}
|
|
}
|
|
ret.Cards = hitCards
|
|
if 1 > len(ret.Cards) {
|
|
ret.Cards = []*av.GalleryCard{}
|
|
}
|
|
}
|
|
|
|
// 自定义排序
|
|
sortCardIDs := map[string]int{}
|
|
if 0 < len(view.Gallery.CardIDs) {
|
|
for i, cardID := range view.Gallery.CardIDs {
|
|
sortCardIDs[cardID] = i
|
|
}
|
|
}
|
|
|
|
sort.Slice(ret.Fields, func(i, j int) bool {
|
|
iv := sortCardIDs[ret.Fields[i].ID]
|
|
jv := sortCardIDs[ret.Fields[j].ID]
|
|
if iv == jv {
|
|
return ret.Fields[i].ID < ret.Fields[j].ID
|
|
}
|
|
return iv < jv
|
|
})
|
|
return
|
|
}
|
|
|
|
func fillGalleryCardCover(attrView *av.AttributeView, view *av.View, cardValues []*av.KeyValues, galleryCard av.GalleryCard, cardID string, luteEngine *lute.Lute) {
|
|
switch view.Gallery.CoverFrom {
|
|
case av.CoverFromNone:
|
|
case av.CoverFromContentImage:
|
|
blockValue := getBlockValue(cardValues)
|
|
if !blockValue.IsDetached {
|
|
tree := loadTreeByBlockID(blockValue.BlockID)
|
|
if nil == tree {
|
|
break
|
|
}
|
|
node := treenode.GetNodeInTree(tree, blockValue.BlockID)
|
|
if nil == node {
|
|
break
|
|
}
|
|
|
|
if ast.NodeDocument == node.Type {
|
|
if titleImg := node.IALAttr("title-img"); "" != titleImg {
|
|
galleryCard.CoverURL = titleImg
|
|
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
|
|
}
|
|
galleryCard.CoverURL = dest.TokensStr()
|
|
return ast.WalkStop
|
|
})
|
|
|
|
if "" == galleryCard.CoverURL {
|
|
if ast.NodeDocument == node.Type {
|
|
galleryCard.CoverContent = node.IALAttr("title")
|
|
return
|
|
}
|
|
|
|
galleryCard.CoverContent = renderBlockDOMByNode(node, luteEngine)
|
|
return
|
|
}
|
|
}
|
|
case av.CoverFromAssetField:
|
|
if "" == view.Gallery.CoverFromAssetKeyID {
|
|
break
|
|
}
|
|
|
|
assetValue := attrView.GetValue(view.Gallery.CoverFromAssetKeyID, cardID)
|
|
if nil == assetValue || 1 > len(assetValue.MAsset) {
|
|
break
|
|
}
|
|
|
|
galleryCard.CoverURL = assetValue.MAsset[0].Content
|
|
return
|
|
}
|
|
}
|
|
|
|
func renderBlockDOMByNode(node *ast.Node, luteEngine *lute.Lute) string {
|
|
tree := &parse.Tree{Root: &ast.Node{Type: ast.NodeDocument}, Context: &parse.Context{ParseOption: luteEngine.ParseOptions}}
|
|
blockRenderer := render.NewProtyleRenderer(tree, luteEngine.RenderOptions)
|
|
ast.Walk(node, func(node *ast.Node, entering bool) ast.WalkStatus {
|
|
rendererFunc := blockRenderer.RendererFuncs[node.Type]
|
|
return rendererFunc(node, entering)
|
|
})
|
|
h := strings.TrimSpace(blockRenderer.Writer.String())
|
|
if strings.HasPrefix(h, "<li") {
|
|
h = "<ul>" + h + "</ul>"
|
|
}
|
|
return h
|
|
}
|