ec1f89217a
Full Mattermost server source with integrated Community Enterprise features. Includes vendor directory for offline/air-gapped builds. Structure: - enterprise-impl/: Enterprise feature implementations - enterprise-community/: Init files that register implementations - enterprise/: Bridge imports (community_imports.go) - vendor/: All dependencies for offline builds Build (online): go build ./cmd/mattermost Build (offline/air-gapped): go build -mod=vendor ./cmd/mattermost 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
83 lines
2.8 KiB
Go
83 lines
2.8 KiB
Go
package grammar
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/splitio/go-split-commons/v7/dtos"
|
|
"golang.org/x/exp/slices"
|
|
)
|
|
|
|
// InRuleBasedsegmentMatcher matches if the key passed is in the rule-based segment which the matcher was constructed with
|
|
type InRuleBasedSegmentMatcher struct {
|
|
Matcher
|
|
name string
|
|
ruleBuilder RuleBuilder
|
|
}
|
|
|
|
// NewInRuleBasedSegmentMatcher instantiates a new InRuleBasedSegmentMatcher
|
|
func NewInRuleBasedSegmentMatcher(negate bool, name string, attributeName *string, ruleBuilder RuleBuilder) *InRuleBasedSegmentMatcher {
|
|
return &InRuleBasedSegmentMatcher{
|
|
Matcher: Matcher{
|
|
negate: negate,
|
|
attributeName: attributeName,
|
|
},
|
|
name: name,
|
|
ruleBuilder: ruleBuilder,
|
|
}
|
|
}
|
|
|
|
// Match returns true if the key is in the matcher's rule-based segment
|
|
func (m *InRuleBasedSegmentMatcher) Match(key string, attributes map[string]interface{}, bucketingKey *string) bool {
|
|
|
|
ruleBasedSegment, err := m.ruleBuilder.ruleBasedSegmentStorage.GetRuleBasedSegmentByName(m.name)
|
|
if err != nil {
|
|
m.logger.Error(fmt.Printf("InRuleBasedSegmentMatcher: Rule-based Segment %s not found", m.name))
|
|
}
|
|
if m.keyIsExcluded(*ruleBasedSegment, key) {
|
|
return false
|
|
}
|
|
if m.inExcludedSegment(*ruleBasedSegment, key, attributes, bucketingKey) {
|
|
return false
|
|
}
|
|
|
|
return m.matchesConditions(*ruleBasedSegment, key, attributes, bucketingKey)
|
|
}
|
|
|
|
func (m *InRuleBasedSegmentMatcher) keyIsExcluded(ruleBasedSegment dtos.RuleBasedSegmentDTO, key string) bool {
|
|
return slices.Contains(ruleBasedSegment.Excluded.Keys, key)
|
|
}
|
|
|
|
func (m *InRuleBasedSegmentMatcher) inExcludedSegment(ruleBasedSegment dtos.RuleBasedSegmentDTO, key string, attributes map[string]interface{}, bucketingKey *string) bool {
|
|
for _, value := range ruleBasedSegment.Excluded.Segments {
|
|
switch value.Type {
|
|
case dtos.TypeStandard:
|
|
segmentMatcher := NewInSegmentMatcher(false, value.Name, m.attributeName, m.ruleBuilder.segmentStorage)
|
|
segmentMatcher.logger = m.logger
|
|
return segmentMatcher.Match(key, attributes, bucketingKey)
|
|
|
|
case dtos.TypeRuleBased:
|
|
ruleBasedSegmentMatcher := NewInRuleBasedSegmentMatcher(false, value.Name, m.attributeName, m.ruleBuilder)
|
|
ruleBasedSegmentMatcher.logger = m.logger
|
|
if ruleBasedSegmentMatcher.Match(key, attributes, bucketingKey) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *InRuleBasedSegmentMatcher) matchesConditions(ruleBasedSegment dtos.RuleBasedSegmentDTO, key string, attributes map[string]interface{}, bucketingKey *string) bool {
|
|
for _, condition := range ruleBasedSegment.Conditions {
|
|
|
|
conditionMatcher, err := NewRBCondition(&condition, m.logger, m.ruleBuilder)
|
|
if err != nil {
|
|
m.logger.Error(fmt.Printf("InRuleBasedSegmentMatcher: error creating new condition"))
|
|
return false
|
|
}
|
|
if conditionMatcher.Matches(key, bucketingKey, attributes) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|