Merge remote-tracking branch 'origin/dev' into dev

kernel/av/filter.go

@@ -268,77 +268,23 @@ 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 {
+			if !other.Number.IsNotEmpty {
+				return true
+			}
+
 			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:
@@ -354,6 +300,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:
@@ -408,111 +360,51 @@ 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 {
-			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) {
@@ -624,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 {
@@ -853,11 +785,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
@@ -865,7 +792,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 {
@@ -884,7 +810,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 +829,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:
@@ -962,14 +884,20 @@ 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:
 			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 +905,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 +915,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 +936,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 +955,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 {

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,19 +107,17 @@ 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 := filter.GetAffectValue(keyValues.Key, addingItemID)
+		if nil == newValue {
 			newValue = getNewValueByNearItem(nearItem, keyValues.Key, addingItemID)
-		} else {
-			// 不存在临近项时通过过滤条件计算新值
-			newValue = filter.GetAffectValue(keyValues.Key, addingItemID)
 		}
 		if nil != newValue {
 			ret[keyValues.Key.ID] = newValue
@@ -131,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 {
@@ -1832,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)
@@ -2971,17 +2970,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) {