Skip to content

Commit bee18d4

Browse files
yhabteabyhabteab
committed
Trigger time based escalations
1 parent 399d3c2 commit bee18d4

File tree

7 files changed

+236
-62
lines changed

7 files changed

+236
-62
lines changed

‎internal/event/event.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ type Event struct {
2828
const (
2929
TypeState = "state"
3030
TypeAcknowledgement = "acknowledgement"
31+
TypeInternal = "internal"
3132
)
3233

3334
func (e *Event) String() string {

‎internal/filter/contracts.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,4 +12,5 @@ type Filterable interface {
1212
// Filter is implemented by every filter chains and filter conditions.
1313
type Filter interface {
1414
Eval(filterable Filterable) (bool, error)
15+
ExtractConditions() []Condition
1516
}

‎internal/filter/parser.go‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -257,24 +257,24 @@ func (p *Parser) createCondition(column string, operator string, value string) (
257257
switch operator {
258258
case "=":
259259
if strings.Contains(value, "*") {
260-
return &Like{column: column, value: value}, nil
260+
return &Like{Condition{Column: column, Value: value}}, nil
261261
}
262262

263-
return &Equal{column: column, value: value}, nil
263+
return &Equal{Condition{Column: column, Value: value}}, nil
264264
case "!=":
265265
if strings.Contains(value, "*") {
266-
return &Unlike{column: column, value: value}, nil
266+
return &Unlike{Condition{Column: column, Value: value}}, nil
267267
}
268268

269-
return &UnEqual{column: column, value: value}, nil
269+
return &UnEqual{Condition{Column: column, Value: value}}, nil
270270
case ">":
271-
return &GreaterThan{column: column, value: value}, nil
271+
return &GreaterThan{Condition{Column: column, Value: value}}, nil
272272
case ">=":
273-
return &GreaterThanOrEqual{column: column, value: value}, nil
273+
return &GreaterThanOrEqual{Condition{Column: column, Value: value}}, nil
274274
case "<":
275-
return &LessThan{column: column, value: value}, nil
275+
return &LessThan{Condition{Column: column, Value: value}}, nil
276276
case "<=":
277-
return &LessThanOrEqual{column: column, value: value}, nil
277+
return &LessThanOrEqual{Condition{Column: column, Value: value}}, nil
278278
default:
279279
return nil, fmt.Errorf("invalid operator %s provided", operator)
280280
}

‎internal/filter/parser_test.go‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -118,12 +118,12 @@ func TestFilter(t *testing.T) {
118118

119119
expected := &All{rules: []Filter{
120120
&None{rules: []Filter{
121-
&Equal{column: "foo", value: "bar"},
122-
&Equal{column: "bar", value: "foo"},
121+
&Equal{Condition{Column: "foo", Value: "bar"}},
122+
&Equal{Condition{Column: "bar", Value: "foo"}},
123123
}},
124124
&Any{rules: []Filter{
125-
&Equal{column: "foo", value: "bar"},
126-
&Equal{column: "bar", value: "foo"},
125+
&Equal{Condition{Column: "foo", Value: "bar"}},
126+
&Equal{Condition{Column: "bar", Value: "foo"}},
127127
}},
128128
}}
129129
assert.Equal(t, expected, rule)
@@ -133,30 +133,30 @@ func TestFilter(t *testing.T) {
133133
rule, err := Parse("foo=bar")
134134
assert.Nil(t, err, "There should be no errors but got: %s", err)
135135

136-
expected := &Equal{column: "foo", value: "bar"}
136+
expected := &Equal{Condition{Column: "foo", Value: "bar"}}
137137
assert.Equal(t, expected, rule, "Parser doesn't parse single condition correctly")
138138
})
139139

140140
t.Run("UrlEncodedFilterExpression", func(t *testing.T) {
141141
rule, err := Parse("col%3Cumn<val%3Cue")
142142
assert.Nil(t, err, "There should be no errors but got: %s", err)
143-
assert.Equal(t, &LessThan{column: "col<umn", value: "val<ue"}, rule)
143+
assert.Equal(t, &LessThan{Condition{Column: "col<umn", Value: "val<ue"}}, rule)
144144

145145
rule, err = Parse("col%7Cumn=val%7Cue")
146146
assert.Nil(t, err, "There should be no errors but got: %s", err)
147-
assert.Equal(t, &Equal{column: "col|umn", value: "val|ue"}, rule)
147+
assert.Equal(t, &Equal{Condition{Column: "col|umn", Value: "val|ue"}}, rule)
148148

149149
rule, err = Parse("col%26umn<=val%26ue")
150150
assert.Nil(t, err, "There should be no errors but got: %s", err)
151-
assert.Equal(t, &LessThanOrEqual{column: "col&umn", value: "val&ue"}, rule)
151+
assert.Equal(t, &LessThanOrEqual{Condition{Column: "col&umn", Value: "val&ue"}}, rule)
152152

153153
rule, err = Parse("col%28umn>val%28ue")
154154
assert.Nil(t, err, "There should be no errors but got: %s", err)
155-
assert.Equal(t, &GreaterThan{column: "col(umn", value: "val(ue"}, rule)
155+
assert.Equal(t, &GreaterThan{Condition{Column: "col(umn", Value: "val(ue"}}, rule)
156156

157157
rule, err = Parse("col%29umn>=val%29ue")
158158
assert.Nil(t, err, "There should be no errors but got: %s", err)
159-
assert.Equal(t, &GreaterThanOrEqual{column: "col)umn", value: "val)ue"}, rule)
159+
assert.Equal(t, &GreaterThanOrEqual{Condition{Column: "col)umn", Value: "val)ue"}}, rule)
160160
})
161161
}
162162

‎internal/filter/types.go‎

Lines changed: 73 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,10 @@ func (a *All) Eval(filterable Filterable) (bool, error) {
2020
return true, nil
2121
}
2222

23+
func (a *All) ExtractConditions() []Condition {
24+
return extractConditions(a.rules)
25+
}
26+
2327
// Any represents a filter chain type that matches when at least one of its Rules matches.
2428
type Any struct {
2529
rules []Filter
@@ -40,6 +44,10 @@ func (a *Any) Eval(filterable Filterable) (bool, error) {
4044
return false, nil
4145
}
4246

47+
func (a *Any) ExtractConditions() []Condition {
48+
return extractConditions(a.rules)
49+
}
50+
4351
// None represents a filter chain type that matches when none of its Rules matches.
4452
type None struct {
4553
rules []Filter
@@ -60,115 +68,151 @@ func (n *None) Eval(filterable Filterable) (bool, error) {
6068
return true, nil
6169
}
6270

71+
func (n *None) ExtractConditions() []Condition {
72+
return extractConditions(n.rules)
73+
}
74+
6375
// Condition represents a single filter condition.
6476
type Condition struct {
65-
column string
66-
value string
77+
Column string
78+
Value string
6779
}
6880

69-
func NewCondition(column string, value string) *Condition {
70-
return &Condition{
71-
column: column,
72-
value: value,
81+
func NewCondition(column string, value string) Condition {
82+
return Condition{
83+
Column: column,
84+
Value: value,
7385
}
7486
}
7587

76-
type Exists Condition
88+
func (e Condition) ExtractConditions() []Condition {
89+
return []Condition{e}
90+
}
91+
92+
type Exists struct {
93+
Condition
94+
}
7795

7896
func NewExists(column string) *Exists {
79-
return &Exists{column: column}
97+
return &Exists{Condition{Column: column}}
8098
}
8199

82100
func (e *Exists) Eval(filterable Filterable) (bool, error) {
83-
return filterable.EvalExists(e.column), nil
101+
return filterable.EvalExists(e.Column), nil
84102
}
85103

86-
type Equal Condition
104+
type Equal struct {
105+
Condition
106+
}
87107

88108
func (e *Equal) Eval(filterable Filterable) (bool, error) {
89-
match, err := filterable.EvalEqual(e.column, e.value)
109+
match, err := filterable.EvalEqual(e.Column, e.Value)
90110
if err != nil {
91111
return false, err
92112
}
93113

94114
return match, nil
95115
}
96116

97-
type UnEqual Condition
117+
type UnEqual struct {
118+
Condition
119+
}
98120

99121
func (u *UnEqual) Eval(filterable Filterable) (bool, error) {
100-
match, err := filterable.EvalEqual(u.column, u.value)
122+
match, err := filterable.EvalEqual(u.Column, u.Value)
101123
if err != nil {
102124
return false, err
103125
}
104126

105-
return filterable.EvalExists(u.column) && !match, nil
127+
return filterable.EvalExists(u.Column) && !match, nil
106128
}
107129

108-
type Like Condition
130+
type Like struct {
131+
Condition
132+
}
109133

110134
func (l *Like) Eval(filterable Filterable) (bool, error) {
111-
match, err := filterable.EvalLike(l.column, l.value)
135+
match, err := filterable.EvalLike(l.Column, l.Value)
112136
if err != nil {
113137
return false, err
114138
}
115139

116140
return match, nil
117141
}
118142

119-
type Unlike Condition
143+
type Unlike struct {
144+
Condition
145+
}
120146

121147
func (u *Unlike) Eval(filterable Filterable) (bool, error) {
122-
match, err := filterable.EvalLike(u.column, u.value)
148+
match, err := filterable.EvalLike(u.Column, u.Value)
123149
if err != nil {
124150
return false, err
125151
}
126152

127-
return filterable.EvalExists(u.column) && !match, nil
153+
return filterable.EvalExists(u.Column) && !match, nil
128154
}
129155

130-
type LessThan Condition
156+
type LessThan struct {
157+
Condition
158+
}
131159

132160
func (less *LessThan) Eval(filterable Filterable) (bool, error) {
133-
match, err := filterable.EvalLess(less.column, less.value)
161+
match, err := filterable.EvalLess(less.Column, less.Value)
134162
if err != nil {
135163
return false, err
136164
}
137165

138166
return match, nil
139167
}
140168

141-
type LessThanOrEqual Condition
169+
type LessThanOrEqual struct {
170+
Condition
171+
}
142172

143173
func (loe *LessThanOrEqual) Eval(filterable Filterable) (bool, error) {
144-
match, err := filterable.EvalLessOrEqual(loe.column, loe.value)
174+
match, err := filterable.EvalLessOrEqual(loe.Column, loe.Value)
145175
if err != nil {
146176
return false, err
147177
}
148178

149179
return match, nil
150180
}
151181

152-
type GreaterThan Condition
182+
type GreaterThan struct {
183+
Condition
184+
}
153185

154186
func (g *GreaterThan) Eval(filterable Filterable) (bool, error) {
155-
match, err := filterable.EvalLessOrEqual(g.column, g.value)
187+
match, err := filterable.EvalLessOrEqual(g.Column, g.Value)
156188
if err != nil {
157189
return false, err
158190
}
159191

160-
return filterable.EvalExists(g.column) && !match, nil
192+
return filterable.EvalExists(g.Column) && !match, nil
161193
}
162194

163-
type GreaterThanOrEqual Condition
195+
type GreaterThanOrEqual struct {
196+
Condition
197+
}
164198

165199
func (goe *GreaterThanOrEqual) Eval(filterable Filterable) (bool, error) {
166-
match, err := filterable.EvalLess(goe.column, goe.value)
200+
match, err := filterable.EvalLess(goe.Column, goe.Value)
167201
if err != nil {
168202
return false, err
169203
}
170204

171-
return filterable.EvalExists(goe.column) && !match, nil
205+
return filterable.EvalExists(goe.Column) && !match, nil
206+
}
207+
208+
// extractConditions extracts filter conditions from the specified filter rules.
209+
func extractConditions(rules []Filter) []Condition {
210+
var conditions []Condition
211+
for _, rule := range rules {
212+
conditions = append(conditions, rule.ExtractConditions()...)
213+
}
214+
215+
return conditions
172216
}
173217

174218
var (

0 commit comments

Comments
 (0)