bin/projects/dbatools/dbatools/Message/MessageEventSubscription.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
using Sqlcollaborative.Dbatools.Utility;
using System;
using System.Collections.Generic;
using System.Management.Automation;

namespace Sqlcollaborative.Dbatools.Message
{
    /// <summary>
    /// Condition and logic to be executed on message events
    /// </summary>
    public class MessageEventSubscription
    {
        /// <summary>
        /// Name of the event subscription, must be unique.
        /// </summary>
        public string Name;

        /// <summary>
        /// Scriptblock to execute if the condition is met
        /// </summary>
        public ScriptBlock ScriptBlock;

        /// <summary>
        /// The internally stored filter value for Message
        /// </summary>
        private string _MessageFilter;
        /// <summary>
        /// The value the Message is filtered by
        /// </summary>
        public string MessageFilter
        {
            get { return _MessageFilter; }
            set
            {
                _MessageFilter = value;
                MessageFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by Message was enabled
        /// </summary>
        public bool MessageFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for ModuleName
        /// </summary>
        private string _ModuleNameFilter;
        /// <summary>
        /// The value the ModuleName is filtered by
        /// </summary>
        public string ModuleNameFilter
        {
            get { return _ModuleNameFilter; }
            set
            {
                _ModuleNameFilter = value;
                ModuleNameFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by ModuleName was enabled
        /// </summary>
        public bool ModuleNameFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for FunctionName
        /// </summary>
        private string _FunctionNameFilter;
        /// <summary>
        /// The value the FunctionName is filtered by
        /// </summary>
        public string FunctionNameFilter
        {
            get { return _FunctionNameFilter; }
            set
            {
                _FunctionNameFilter = value;
                FunctionNameFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by FunctionName was enabled
        /// </summary>
        public bool FunctionNameFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for Target
        /// </summary>
        private object _TargetFilter;
        /// <summary>
        /// The value the Target is filtered by
        /// </summary>
        public object TargetFilter
        {
            get { return _TargetFilter; }
            set
            {
                _TargetFilter = value;
                TargetFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by Target was enabled
        /// </summary>
        public bool TargetFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for Level
        /// </summary>
        private List<MessageLevel> _LevelFilter;
        /// <summary>
        /// The value the Level is filtered by
        /// </summary>
        public List<MessageLevel> LevelFilter
        {
            get { return _LevelFilter; }
            set
            {
                _LevelFilter = value;
                LevelFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by Level was enabled
        /// </summary>
        public bool LevelFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for Tag
        /// </summary>
        private List<string> _TagFilter;
        /// <summary>
        /// The value the Tag is filtered by
        /// </summary>
        public List<string> TagFilter
        {
            get { return _TagFilter; }
            set
            {
                _TagFilter = value;
                TagFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by Tag was enabled
        /// </summary>
        public bool TagFilterSet { get; private set; }

        /// <summary>
        /// The internally stored filter value for Runspace
        /// </summary>
        private Guid _RunspaceFilter;
        /// <summary>
        /// The value the Runspace is filtered by
        /// </summary>
        public Guid RunspaceFilter
        {
            get { return _RunspaceFilter; }
            set
            {
                _RunspaceFilter = value;
                RunspaceFilterSet = true;
            }
        }
        /// <summary>
        /// Whether filtering by Runspace was enabled
        /// </summary>
        public bool RunspaceFilterSet { get; private set; }

        /// <summary>
        /// Checks, whether a given entry matches the filter defined in this subscription
        /// </summary>
        /// <param name="Entry">The entry to validate</param>
        /// <returns>Whether the subscription should react to this entry</returns>
        public bool Applies(LogEntry Entry)
        {
            if (MessageFilterSet && !UtilityHost.IsLike(Entry.Message, MessageFilter))
                return false;
            if (ModuleNameFilterSet && !UtilityHost.IsLike(Entry.ModuleName, ModuleNameFilter))
                return false;
            if (FunctionNameFilterSet && !UtilityHost.IsLike(Entry.FunctionName, FunctionNameFilter))
                return false;
            if (TargetFilterSet && (Entry.TargetObject != TargetFilter))
                return false;
            if (LevelFilterSet && !LevelFilter.Contains(Entry.Level))
                return false;
            if (TagFilterSet)
            {
                bool test = false;

                foreach (string tag in TagFilter)
                    foreach (string tag2 in Entry.Tags)
                        if (tag == tag2)
                            test = true;

                if (!test)
                    return false;
            }
            if (RunspaceFilterSet && RunspaceFilter != Entry.Runspace)
                return false;

            return true;
        }
    }
}