From 120b0c1e57a1eb4e21431299f3c09d792f06358a Mon Sep 17 00:00:00 2001 From: Daniel <845765@qq.com> Date: Tue, 12 Aug 2025 10:59:14 +0800 Subject: [PATCH 1/6] :art: Improve database field default filling https://github.com/siyuan-note/siyuan/issues/11966 --- kernel/av/filter.go | 41 ++++++++++++---------------------- kernel/model/attribute_view.go | 24 ++++++++++++-------- 2 files changed, 29 insertions(+), 36 deletions(-) diff --git a/kernel/av/filter.go b/kernel/av/filter.go index 65ef4330f..b404b5148 100644 --- a/kernel/av/filter.go +++ b/kernel/av/filter.go @@ -330,15 +330,9 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa if nil != value.Number && nil != other && nil != other.Number { switch operator { case FilterOperatorIsEqual: - if !other.Number.IsNotEmpty { - return true - } - return value.Number.Content == other.Number.Content + return value.Number.Content == other.Number.Content && value.Number.IsNotEmpty == other.Number.IsNotEmpty case FilterOperatorIsNotEqual: - if !other.Number.IsNotEmpty { - return true - } - return value.Number.Content != other.Number.Content + return value.Number.Content != other.Number.Content || value.Number.IsNotEmpty != other.Number.IsNotEmpty case FilterOperatorIsGreater: return value.Number.Content > other.Number.Content case FilterOperatorIsGreaterOrEqual: @@ -853,11 +847,6 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V } } - if FilterOperatorIsNotEmpty == filter.Operator { - // 在过滤非空值的情况下，不设置默认值 https://github.com/siyuan-note/siyuan/issues/15540 - return nil - } - ret = filter.Value.Clone() ret.ID = ast.NewNodeID() ret.KeyID = key.ID @@ -884,7 +873,7 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsEmpty: ret.Block = &ValueBlock{Content: "", Created: ret.CreatedAt, Updated: ret.UpdatedAt} case FilterOperatorIsNotEmpty: - ret.Block = &ValueBlock{Content: "", Created: ret.CreatedAt, Updated: ret.UpdatedAt} + return nil } case KeyTypeText: switch filter.Operator { @@ -903,18 +892,14 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsEmpty: ret.Text = &ValueText{Content: ""} case FilterOperatorIsNotEmpty: - ret.Text = &ValueText{Content: ""} + return nil } case KeyTypeNumber: switch filter.Operator { case FilterOperatorIsEqual: ret.Number = &ValueNumber{Content: filter.Value.Number.Content, IsNotEmpty: false} case FilterOperatorIsNotEqual: - if 0 == filter.Value.Number.Content { - ret.Number = &ValueNumber{Content: 1, IsNotEmpty: true} - } else { - ret.Number = &ValueNumber{Content: 0, IsNotEmpty: true} - } + ret.Number = &ValueNumber{Content: 0, IsNotEmpty: false} case FilterOperatorIsGreater: ret.Number = &ValueNumber{Content: filter.Value.Number.Content + 1, IsNotEmpty: true} case FilterOperatorIsGreaterOrEqual: @@ -970,6 +955,8 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsNotEmpty: if 0 < len(key.Options) { ret.MSelect = []*ValueSelect{{Content: key.Options[0].Name, Color: key.Options[0].Color}} + } else { + return nil } } case KeyTypeURL: @@ -977,7 +964,7 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsEqual: ret.URL = &ValueURL{Content: filter.Value.URL.Content} case FilterOperatorIsNotEqual: - ret.URL = &ValueURL{Content: filter.Value.URL.Content} + ret.URL = &ValueURL{Content: ""} case FilterOperatorContains: ret.URL = &ValueURL{Content: filter.Value.URL.Content} case FilterOperatorDoesNotContain: @@ -987,16 +974,16 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorEndsWith: ret.URL = &ValueURL{Content: filter.Value.URL.Content} case FilterOperatorIsEmpty: - ret.URL = &ValueURL{} + ret.URL = &ValueURL{Content: ""} case FilterOperatorIsNotEmpty: - ret.URL = &ValueURL{} + return nil } case KeyTypeEmail: switch filter.Operator { case FilterOperatorIsEqual: ret.Email = &ValueEmail{Content: filter.Value.Email.Content} case FilterOperatorIsNotEqual: - ret.Email = &ValueEmail{Content: filter.Value.Email.Content} + ret.Email = &ValueEmail{Content: ""} case FilterOperatorContains: ret.Email = &ValueEmail{Content: filter.Value.Email.Content} case FilterOperatorDoesNotContain: @@ -1008,14 +995,14 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsEmpty: ret.Email = &ValueEmail{Content: ""} case FilterOperatorIsNotEmpty: - ret.Email = &ValueEmail{Content: ""} + return nil } case KeyTypePhone: switch filter.Operator { case FilterOperatorIsEqual: ret.Phone = &ValuePhone{Content: filter.Value.Phone.Content} case FilterOperatorIsNotEqual: - ret.Phone = &ValuePhone{Content: filter.Value.Phone.Content + ""} + ret.Phone = &ValuePhone{Content: ""} case FilterOperatorContains: ret.Phone = &ValuePhone{Content: filter.Value.Phone.Content} case FilterOperatorDoesNotContain: @@ -1027,7 +1014,7 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V case FilterOperatorIsEmpty: ret.Phone = &ValuePhone{Content: ""} case FilterOperatorIsNotEmpty: - ret.Phone = &ValuePhone{Content: ""} + return nil } case KeyTypeMAsset: switch filter.Operator { diff --git a/kernel/model/attribute_view.go b/kernel/model/attribute_view.go index 234bbb19b..82e29a14e 100644 --- a/kernel/model/attribute_view.go +++ b/kernel/model/attribute_view.go @@ -86,10 +86,6 @@ func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, group } nearItem := getNearItem(attrView, view, groupView, previousItemID) - filterKeyIDs := map[string]bool{} - for _, f := range view.Filters { - filterKeyIDs[f.Column] = true - } // 对库中存在模板字段和汇总字段的情况进行处理（尽量从临近项获取新值，获取不到的话直接返回） existSpecialField := false @@ -111,20 +107,30 @@ func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, group } } + filterKeyIDs := map[string]bool{} for _, filter := range view.Filters { + filterKeyIDs[filter.Column] = true keyValues, _ := attrView.GetKeyValues(filter.Column) if nil == keyValues { continue } var newValue *av.Value - if nil != nearItem { - // 存在临近项时优先通过临近项获取新值 - newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) - } else { - // 不存在临近项时通过过滤条件计算新值 + + switch keyValues.Key.Type { + case av.KeyTypeNumber: newValue = filter.GetAffectValue(keyValues.Key, addingItemID) + if nil == newValue { + newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) + } + default: + if nil != nearItem { + newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) + } else { + newValue = filter.GetAffectValue(keyValues.Key, addingItemID) + } } + if nil != newValue { ret[keyValues.Key.ID] = newValue } From 1136c1c4935d685f07b385678eda2b0be6be430d Mon Sep 17 00:00:00 2001 From: Daniel <845765@qq.com> Date: Tue, 12 Aug 2025 11:36:58 +0800 Subject: [PATCH 2/6] :art: Improve database field default filling https://github.com/siyuan-note/siyuan/issues/11966 --- kernel/av/filter.go | 70 +++++++++++++++++----------------- kernel/model/attribute_view.go | 18 ++------- 2 files changed, 37 insertions(+), 51 deletions(-) diff --git a/kernel/av/filter.go b/kernel/av/filter.go index b404b5148..4be905f0a 100644 --- a/kernel/av/filter.go +++ b/kernel/av/filter.go @@ -328,6 +328,10 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa } case KeyTypeNumber: if nil != value.Number && nil != other && nil != other.Number { + if !other.Number.IsNotEmpty { + return true + } + switch operator { case FilterOperatorIsEqual: return value.Number.Content == other.Number.Content && value.Number.IsNotEmpty == other.Number.IsNotEmpty @@ -402,48 +406,39 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa } case KeyTypeSelect, KeyTypeMSelect: if nil != value.MSelect { - if nil != other && nil != other.MSelect { - switch operator { - case FilterOperatorIsEqual, FilterOperatorContains: - contains := false - for _, v := range value.MSelect { - for _, v2 := range other.MSelect { - if v.Content == v2.Content { - contains = true - break - } - } - } - return contains - case FilterOperatorIsNotEqual, FilterOperatorDoesNotContain: - contains := false - for _, v := range value.MSelect { - for _, v2 := range other.MSelect { - if v.Content == v2.Content { - contains = true - break - } - } - } - return !contains - case FilterOperatorIsEmpty: - return 0 == len(value.MSelect) || 1 == len(value.MSelect) && "" == value.MSelect[0].Content - case FilterOperatorIsNotEmpty: - return 0 != len(value.MSelect) && !(1 == len(value.MSelect) && "" == value.MSelect[0].Content) - } - return false + if nil == other || nil == other.MSelect || 1 > len(other.MSelect) { + return true } - // 没有设置比较值 - switch operator { - case FilterOperatorIsEqual, FilterOperatorIsNotEqual, FilterOperatorContains, FilterOperatorDoesNotContain: - return true + case FilterOperatorIsEqual, FilterOperatorContains: + contains := false + for _, v := range value.MSelect { + for _, v2 := range other.MSelect { + if v.Content == v2.Content { + contains = true + break + } + } + } + return contains + case FilterOperatorIsNotEqual, FilterOperatorDoesNotContain: + contains := false + for _, v := range value.MSelect { + for _, v2 := range other.MSelect { + if v.Content == v2.Content { + contains = true + break + } + } + } + return !contains case FilterOperatorIsEmpty: return 0 == len(value.MSelect) || 1 == len(value.MSelect) && "" == value.MSelect[0].Content case FilterOperatorIsNotEmpty: return 0 != len(value.MSelect) && !(1 == len(value.MSelect) && "" == value.MSelect[0].Content) } + return false } case KeyTypeURL: if nil != value.URL && nil != other && nil != other.URL { @@ -854,7 +849,6 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V ret.CreatedAt = util.CurrentTimeMillis() ret.UpdatedAt = ret.CreatedAt + 1000 - // 没有默认值则使用过滤条件的值 switch filter.Value.Type { case KeyTypeBlock: switch filter.Operator { @@ -947,9 +941,13 @@ func (filter *ViewFilter) GetAffectValue(key *Key, addingBlockID string) (ret *V } ret.MSelect = []*ValueSelect{valueSelect} case FilterOperatorIsNotEqual: + return nil + case FilterOperatorContains: if 0 < len(filter.Value.MSelect) { - ret.MSelect = []*ValueSelect{} + ret.MSelect = []*ValueSelect{{Content: filter.Value.MSelect[0].Content, Color: filter.Value.MSelect[0].Color}} } + case FilterOperatorDoesNotContain: + return nil case FilterOperatorIsEmpty: ret.MSelect = []*ValueSelect{} case FilterOperatorIsNotEmpty: diff --git a/kernel/model/attribute_view.go b/kernel/model/attribute_view.go index 82e29a14e..f7bcd7b65 100644 --- a/kernel/model/attribute_view.go +++ b/kernel/model/attribute_view.go @@ -115,22 +115,10 @@ func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, group continue } - var newValue *av.Value - - switch keyValues.Key.Type { - case av.KeyTypeNumber: - newValue = filter.GetAffectValue(keyValues.Key, addingItemID) - if nil == newValue { - newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) - } - default: - if nil != nearItem { - newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) - } else { - newValue = filter.GetAffectValue(keyValues.Key, addingItemID) - } + newValue := filter.GetAffectValue(keyValues.Key, addingItemID) + if nil == newValue { + newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID) } - if nil != newValue { ret[keyValues.Key.ID] = newValue } From c9530ea1c2b4ad8ff21ec5efaddea14f2c80c038 Mon Sep 17 00:00:00 2001 From: Daniel <845765@qq.com> Date: Tue, 12 Aug 2025 11:50:43 +0800 Subject: [PATCH 3/6] :art: Improve database field default filling https://github.com/siyuan-note/siyuan/issues/11966 https://github.com/siyuan-note/siyuan/issues/15535 --- kernel/av/filter.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/kernel/av/filter.go b/kernel/av/filter.go index 4be905f0a..9fb3639eb 100644 --- a/kernel/av/filter.go +++ b/kernel/av/filter.go @@ -352,6 +352,12 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa } } case KeyTypeDate: + if nil != value.Date && nil != other && nil != other.Date { + if !other.Date.IsNotEmpty { + return true + } + } + if nil != value.Date { switch operator { case FilterOperatorIsEmpty: From 7e11be9d2551ff1865ba1943738162df083f8ed6 Mon Sep 17 00:00:00 2001 From: Daniel <845765@qq.com> Date: Tue, 12 Aug 2025 11:59:24 +0800 Subject: [PATCH 4/6] :art: Improve database field default filling https://github.com/siyuan-note/siyuan/issues/11966 https://github.com/siyuan-note/siyuan/issues/15535 --- kernel/av/filter.go | 153 +++++++++++++------------------------------- 1 file changed, 45 insertions(+), 108 deletions(-) diff --git a/kernel/av/filter.go b/kernel/av/filter.go index 9fb3639eb..651148394 100644 --- a/kernel/av/filter.go +++ b/kernel/av/filter.go @@ -268,63 +268,11 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa switch value.Type { case KeyTypeBlock: if nil != value.Block && nil != other && nil != other.Block { - switch operator { - case FilterOperatorIsEqual: - return value.Block.Content == other.Block.Content - case FilterOperatorIsNotEqual: - return value.Block.Content != other.Block.Content - case FilterOperatorContains: - return strings.Contains(value.Block.Content, other.Block.Content) - case FilterOperatorDoesNotContain: - return !strings.Contains(value.Block.Content, other.Block.Content) - case FilterOperatorStartsWith: - return strings.HasPrefix(value.Block.Content, other.Block.Content) - case FilterOperatorEndsWith: - return strings.HasSuffix(value.Block.Content, other.Block.Content) - case FilterOperatorIsEmpty: - return "" == strings.TrimSpace(value.Block.Content) - case FilterOperatorIsNotEmpty: - return "" != strings.TrimSpace(value.Block.Content) - } + return filterTextContent(operator, value.Block.Content, other.Block.Content) } case KeyTypeText: if nil != value.Text && nil != other && nil != other.Text { - switch operator { - case FilterOperatorIsEqual: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return value.Text.Content == other.Text.Content - case FilterOperatorIsNotEqual: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return value.Text.Content != other.Text.Content - case FilterOperatorContains: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return strings.Contains(value.Text.Content, other.Text.Content) - case FilterOperatorDoesNotContain: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return !strings.Contains(value.Text.Content, other.Text.Content) - case FilterOperatorStartsWith: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return strings.HasPrefix(value.Text.Content, other.Text.Content) - case FilterOperatorEndsWith: - if "" == strings.TrimSpace(other.Text.Content) { - return true - } - return strings.HasSuffix(value.Text.Content, other.Text.Content) - case FilterOperatorIsEmpty: - return "" == strings.TrimSpace(value.Text.Content) - case FilterOperatorIsNotEmpty: - return "" != strings.TrimSpace(value.Text.Content) - } + return filterTextContent(operator, value.Text.Content, other.Text.Content) } case KeyTypeNumber: if nil != value.Number && nil != other && nil != other.Number { @@ -448,66 +396,15 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa } case KeyTypeURL: if nil != value.URL && nil != other && nil != other.URL { - switch operator { - case FilterOperatorIsEqual: - return value.URL.Content == other.URL.Content - case FilterOperatorIsNotEqual: - return value.URL.Content != other.URL.Content - case FilterOperatorContains: - return strings.Contains(value.URL.Content, other.URL.Content) - case FilterOperatorDoesNotContain: - return !strings.Contains(value.URL.Content, other.URL.Content) - case FilterOperatorStartsWith: - return strings.HasPrefix(value.URL.Content, other.URL.Content) - case FilterOperatorEndsWith: - return strings.HasSuffix(value.URL.Content, other.URL.Content) - case FilterOperatorIsEmpty: - return "" == strings.TrimSpace(value.URL.Content) - case FilterOperatorIsNotEmpty: - return "" != strings.TrimSpace(value.URL.Content) - } + return filterTextContent(operator, value.URL.Content, other.URL.Content) } case KeyTypeEmail: if nil != value.Email && nil != other && nil != other.Email { - switch operator { - case FilterOperatorIsEqual: - return value.Email.Content == other.Email.Content - case FilterOperatorIsNotEqual: - return value.Email.Content != other.Email.Content - case FilterOperatorContains: - return strings.Contains(value.Email.Content, other.Email.Content) - case FilterOperatorDoesNotContain: - return !strings.Contains(value.Email.Content, other.Email.Content) - case FilterOperatorStartsWith: - return strings.HasPrefix(value.Email.Content, other.Email.Content) - case FilterOperatorEndsWith: - return strings.HasSuffix(value.Email.Content, other.Email.Content) - case FilterOperatorIsEmpty: - return "" == strings.TrimSpace(value.Email.Content) - case FilterOperatorIsNotEmpty: - return "" != strings.TrimSpace(value.Email.Content) - } + return filterTextContent(operator, value.Email.Content, other.URL.Content) } case KeyTypePhone: if nil != value.Phone && nil != other && nil != other.Phone { - switch operator { - case FilterOperatorIsEqual: - return value.Phone.Content == other.Phone.Content - case FilterOperatorIsNotEqual: - return value.Phone.Content != other.Phone.Content - case FilterOperatorContains: - return strings.Contains(value.Phone.Content, other.Phone.Content) - case FilterOperatorDoesNotContain: - return !strings.Contains(value.Phone.Content, other.Phone.Content) - case FilterOperatorStartsWith: - return strings.HasPrefix(value.Phone.Content, other.Phone.Content) - case FilterOperatorEndsWith: - return strings.HasSuffix(value.Phone.Content, other.Phone.Content) - case FilterOperatorIsEmpty: - return "" == strings.TrimSpace(value.Phone.Content) - case FilterOperatorIsNotEmpty: - return "" != strings.TrimSpace(value.Phone.Content) - } + return filterTextContent(operator, value.Phone.Content, other.Phone.Content) } case KeyTypeMAsset: if nil != value.MAsset && nil != other && nil != other.MAsset && 0 < len(value.MAsset) && 0 < len(other.MAsset) { @@ -619,6 +516,46 @@ func (value *Value) filter(other *Value, relativeDate, relativeDate2 *RelativeDa return false } +func filterTextContent(operator FilterOperator, valueContent, otherValueContent string) bool { + switch operator { + case FilterOperatorIsEqual: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return valueContent == otherValueContent + case FilterOperatorIsNotEqual: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return valueContent != otherValueContent + case FilterOperatorContains: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return strings.Contains(valueContent, otherValueContent) + case FilterOperatorDoesNotContain: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return !strings.Contains(valueContent, otherValueContent) + case FilterOperatorStartsWith: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return strings.HasPrefix(valueContent, otherValueContent) + case FilterOperatorEndsWith: + if "" == strings.TrimSpace(otherValueContent) { + return true + } + return strings.HasSuffix(valueContent, otherValueContent) + case FilterOperatorIsEmpty: + return "" == strings.TrimSpace(valueContent) + case FilterOperatorIsNotEmpty: + return "" != strings.TrimSpace(valueContent) + } + return false +} + func filterRelativeTime(valueMills int64, valueIsNotEmpty bool, operator FilterOperator, otherValueStart, otherValueEnd time.Time, direction RelativeDateDirection, otherValueStart2, otherValueEnd2 time.Time, direction2 RelativeDateDirection) bool { valueTime := time.UnixMilli(valueMills) switch operator { From 5becccc176ea4a9036cbce00a17782b8e7491666 Mon Sep 17 00:00:00 2001 From: Daniel <845765@qq.com> Date: Tue, 12 Aug 2025 17:55:49 +0800 Subject: [PATCH 5/6] :art: Improve database field default filling https://github.com/siyuan-note/siyuan/issues/15543 https://github.com/siyuan-note/siyuan/issues/15540 --- kernel/model/attribute_view.go | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/kernel/model/attribute_view.go b/kernel/model/attribute_view.go index f7bcd7b65..11f9802d2 100644 --- a/kernel/model/attribute_view.go +++ b/kernel/model/attribute_view.go @@ -125,7 +125,7 @@ func getAttrViewAddingBlockDefaultValues(attrView *av.AttributeView, view, group } groupKey := view.GetGroupKey(attrView) - if nil != groupKey && !filterKeyIDs[groupKey.ID] /* 命中了过滤条件的话就不重复处理了 */ { + if nil != groupKey && !filterKeyIDs[groupKey.ID] /* 命中了过滤条件的话就不重复处理了 */ && nil != nearItem { if keyValues, _ := attrView.GetKeyValues(groupKey.ID); nil != keyValues { newValue := getNewValueByNearItem(nearItem, groupKey, addingItemID) if av.KeyTypeSelect == groupKey.Type || av.KeyTypeMSelect == groupKey.Type { @@ -2965,17 +2965,18 @@ func fillDefaultValue(attrView *av.AttributeView, view, groupView *av.View, prev } func getNewValueByNearItem(nearItem av.Item, key *av.Key, addingBlockID string) (ret *av.Value) { - if nil != nearItem { - defaultVal := nearItem.GetValue(key.ID) - ret = defaultVal.Clone() - ret.ID = ast.NewNodeID() - ret.KeyID = key.ID - ret.BlockID = addingBlockID - ret.CreatedAt = util.CurrentTimeMillis() - ret.UpdatedAt = ret.CreatedAt + 1000 + if nil == nearItem { return } - return av.GetAttributeViewDefaultValue(ast.NewNodeID(), key.ID, addingBlockID, key.Type) + + defaultVal := nearItem.GetValue(key.ID) + ret = defaultVal.Clone() + ret.ID = ast.NewNodeID() + ret.KeyID = key.ID + ret.BlockID = addingBlockID + ret.CreatedAt = util.CurrentTimeMillis() + ret.UpdatedAt = ret.CreatedAt + 1000 + return } func getNearItem(attrView *av.AttributeView, view, groupView *av.View, previousItemID string) (ret av.Item) { From b1c0365e56db1f3f4df7754d2eaf104c8269d9f2 Mon Sep 17 00:00:00 2001 From: Jiangshuon <67137548+Jiangshuon@users.noreply.github.com> Date: Tue, 12 Aug 2025 18:06:05 +0800 Subject: [PATCH 6/6] :art: Imporve database image browsing (#15548) --- kernel/model/attribute_view.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/kernel/model/attribute_view.go b/kernel/model/attribute_view.go index 11f9802d2..ed3ce0358 100644 --- a/kernel/model/attribute_view.go +++ b/kernel/model/attribute_view.go @@ -1826,9 +1826,14 @@ func GetCurrentAttributeViewImages(avID, viewID, query string) (ret []string, er av.Filter(table, attrView) av.Sort(table, attrView) + ids:= map[string]bool{} + for _, column := range table.Columns { + ids[column.ID] = column.Hidden + } + for _, row := range table.Rows { for _, cell := range row.Cells { - if nil != cell.Value && av.KeyTypeMAsset == cell.Value.Type && nil != cell.Value.MAsset { + if nil != cell.Value && av.KeyTypeMAsset == cell.Value.Type && nil != cell.Value.MAsset && !ids[cell.Value.KeyID]{ for _, a := range cell.Value.MAsset { if av.AssetTypeImage == a.Type { ret = append(ret, a.Content)