Skip to content

Commit b5bcddf

Browse files
yhabteabyhabteab
committed
Trigger time based escalations
1 parent 9195370 commit b5bcddf

File tree

7 files changed

+219
-62
lines changed

7 files changed

+219
-62
lines changed

‎internal/event/event.go‎

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

3435
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: 72 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,14 @@
11
package filter
22

3+
var extractChain = func(rules []Filter) []Condition {
4+
var conditions []Condition
5+
for _, rule := range rules {
6+
conditions = append(conditions, rule.ExtractConditions()...)
7+
}
8+
9+
return conditions
10+
}
11+
312
// All represents a filter chain type that matches when all of its Rules matches.
413
type All struct {
514
rules []Filter
@@ -20,6 +29,10 @@ func (a *All) Eval(filterable Filterable) (bool, error) {
2029
return true, nil
2130
}
2231

32+
func (a *All) ExtractConditions() []Condition {
33+
return extractChain(a.rules)
34+
}
35+
2336
// Any represents a filter chain type that matches when at least one of its Rules matches.
2437
type Any struct {
2538
rules []Filter
@@ -40,6 +53,10 @@ func (a *Any) Eval(filterable Filterable) (bool, error) {
4053
return false, nil
4154
}
4255

56+
func (a *Any) ExtractConditions() []Condition {
57+
return extractChain(a.rules)
58+
}
59+
4360
// None represents a filter chain type that matches when none of its Rules matches.
4461
type None struct {
4562
rules []Filter
@@ -60,115 +77,141 @@ func (n *None) Eval(filterable Filterable) (bool, error) {
6077
return true, nil
6178
}
6279

80+
func (n *None) ExtractConditions() []Condition {
81+
return extractChain(n.rules)
82+
}
83+
6384
// Condition represents a single filter condition.
6485
type Condition struct {
65-
column string
66-
value string
86+
Column string
87+
Value string
6788
}
6889

69-
func NewCondition(column string, value string) *Condition {
70-
return &Condition{
71-
column: column,
72-
value: value,
90+
func NewCondition(column string, value string) Condition {
91+
return Condition{
92+
Column: column,
93+
Value: value,
7394
}
7495
}
7596

76-
type Exists Condition
97+
func (e Condition) ExtractConditions() []Condition {
98+
return []Condition{e}
99+
}
100+
101+
type Exists struct {
102+
Condition
103+
}
77104

78105
func NewExists(column string) *Exists {
79-
return &Exists{column: column}
106+
return &Exists{Condition{Column: column}}
80107
}
81108

82109
func (e *Exists) Eval(filterable Filterable) (bool, error) {
83-
return filterable.EvalExists(e.column), nil
110+
return filterable.EvalExists(e.Column), nil
84111
}
85112

86-
type Equal Condition
113+
type Equal struct {
114+
Condition
115+
}
87116

88117
func (e *Equal) Eval(filterable Filterable) (bool, error) {
89-
match, err := filterable.EvalEqual(e.column, e.value)
118+
match, err := filterable.EvalEqual(e.Column, e.Value)
90119
if err != nil {
91120
return false, err
92121
}
93122

94123
return match, nil
95124
}
96125

97-
type UnEqual Condition
126+
type UnEqual struct {
127+
Condition
128+
}
98129

99130
func (u *UnEqual) Eval(filterable Filterable) (bool, error) {
100-
match, err := filterable.EvalEqual(u.column, u.value)
131+
match, err := filterable.EvalEqual(u.Column, u.Value)
101132
if err != nil {
102133
return false, err
103134
}
104135

105-
return filterable.EvalExists(u.column) && !match, nil
136+
return filterable.EvalExists(u.Column) && !match, nil
106137
}
107138

108-
type Like Condition
139+
type Like struct {
140+
Condition
141+
}
109142

110143
func (l *Like) Eval(filterable Filterable) (bool, error) {
111-
match, err := filterable.EvalLike(l.column, l.value)
144+
match, err := filterable.EvalLike(l.Column, l.Value)
112145
if err != nil {
113146
return false, err
114147
}
115148

116149
return match, nil
117150
}
118151

119-
type Unlike Condition
152+
type Unlike struct {
153+
Condition
154+
}
120155

121156
func (u *Unlike) Eval(filterable Filterable) (bool, error) {
122-
match, err := filterable.EvalLike(u.column, u.value)
157+
match, err := filterable.EvalLike(u.Column, u.Value)
123158
if err != nil {
124159
return false, err
125160
}
126161

127-
return filterable.EvalExists(u.column) && !match, nil
162+
return filterable.EvalExists(u.Column) && !match, nil
128163
}
129164

130-
type LessThan Condition
165+
type LessThan struct {
166+
Condition
167+
}
131168

132169
func (less *LessThan) Eval(filterable Filterable) (bool, error) {
133-
match, err := filterable.EvalLess(less.column, less.value)
170+
match, err := filterable.EvalLess(less.Column, less.Value)
134171
if err != nil {
135172
return false, err
136173
}
137174

138175
return match, nil
139176
}
140177

141-
type LessThanOrEqual Condition
178+
type LessThanOrEqual struct {
179+
Condition
180+
}
142181

143182
func (loe *LessThanOrEqual) Eval(filterable Filterable) (bool, error) {
144-
match, err := filterable.EvalLessOrEqual(loe.column, loe.value)
183+
match, err := filterable.EvalLessOrEqual(loe.Column, loe.Value)
145184
if err != nil {
146185
return false, err
147186
}
148187

149188
return match, nil
150189
}
151190

152-
type GreaterThan Condition
191+
type GreaterThan struct {
192+
Condition
193+
}
153194

154195
func (g *GreaterThan) Eval(filterable Filterable) (bool, error) {
155-
match, err := filterable.EvalLessOrEqual(g.column, g.value)
196+
match, err := filterable.EvalLessOrEqual(g.Column, g.Value)
156197
if err != nil {
157198
return false, err
158199
}
159200

160-
return filterable.EvalExists(g.column) && !match, nil
201+
return filterable.EvalExists(g.Column) && !match, nil
161202
}
162203

163-
type GreaterThanOrEqual Condition
204+
type GreaterThanOrEqual struct {
205+
Condition
206+
}
164207

165208
func (goe *GreaterThanOrEqual) Eval(filterable Filterable) (bool, error) {
166-
match, err := filterable.EvalLess(goe.column, goe.value)
209+
match, err := filterable.EvalLess(goe.Column, goe.Value)
167210
if err != nil {
168211
return false, err
169212
}
170213

171-
return filterable.EvalExists(goe.column) && !match, nil
214+
return filterable.EvalExists(goe.Column) && !match, nil
172215
}
173216

174217
var (

0 commit comments

Comments
 (0)