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 package ca.uhn.hl7v2.validation.builder;
27
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.HashSet;
33 import java.util.List;
34 import java.util.Set;
35
36 import ca.uhn.hl7v2.HL7Exception;
37 import ca.uhn.hl7v2.Version;
38 import ca.uhn.hl7v2.model.Message;
39 import ca.uhn.hl7v2.util.Terser;
40 import ca.uhn.hl7v2.validation.MessageRule;
41 import ca.uhn.hl7v2.validation.PrimitiveTypeRule;
42 import ca.uhn.hl7v2.validation.Rule;
43 import ca.uhn.hl7v2.Severity;
44 import ca.uhn.hl7v2.validation.ValidationException;
45 import ca.uhn.hl7v2.validation.impl.AbstractMessageRule;
46 import ca.uhn.hl7v2.validation.impl.RuleBinding;
47 import ca.uhn.hl7v2.validation.impl.RuleSupport;
48
49
50
51
52
53
54
55
56
57 @SuppressWarnings("serial")
58 public class RuleTypeBuilder<S extends RuleTypeBuilder<S, T>, T extends Rule<?>> extends
59 BuilderSupport {
60
61 private List<RuleBinding<? extends Rule<?>>> rules = new ArrayList<>();
62 private Set<Version> versions;
63 private String description;
64 private String sectionReference;
65 private boolean active = true;
66 private Severity severity = Severity.ERROR;
67
68 protected RuleTypeBuilder() {
69 super();
70 }
71
72 protected RuleTypeBuilder(List<RuleBinding<? extends Rule<?>>> rules, Set<Version> versions) {
73 super();
74 if (versions.size() == 0)
75 throw new IllegalArgumentException("Must specify a version");
76 this.rules = rules;
77 this.versions = versions;
78 }
79
80 protected RuleTypeBuilder(List<RuleBinding<? extends Rule<?>>> rules, Version... versions) {
81 super();
82 if (versions.length == 0)
83 throw new IllegalArgumentException("Must specify a version");
84 this.rules = rules;
85 this.versions = new HashSet<>(Arrays.asList(versions));
86 }
87
88 @SuppressWarnings("unchecked")
89 protected S instance() {
90 return (S) this;
91 }
92
93 protected List<RuleBinding<? extends Rule<?>>> getRules() {
94 return rules;
95 }
96
97 protected T prepareRule(T rule) {
98 if (rule instanceof RuleSupport) {
99 RuleSupport<?> rs = (RuleSupport<?>) rule;
100 if (description != null) rs.setDescription(description);
101 if (sectionReference != null) rs.setSectionReference(sectionReference);
102 rs.setSeverity(severity);
103 }
104 return rule;
105 }
106
107
108
109
110
111
112
113 public S description(String description) {
114 this.description = description;
115 return instance();
116 }
117
118
119
120
121
122
123
124 public S refersToSection(String sectionReference) {
125 this.sectionReference = sectionReference;
126 return instance();
127 }
128
129
130
131
132
133
134
135 public S severity(Severity severity) {
136 this.severity = severity;
137 return instance();
138 }
139
140
141
142
143
144
145
146 public S active(boolean active) {
147 this.active = active;
148 return instance();
149 }
150
151
152
153
154
155
156
157 public S test(T rule) {
158 addRuleBindings(rule);
159 return instance();
160 }
161
162
163
164
165
166
167
168 public PrimitiveRuleBuilder primitive(String... type) {
169 if (type.length == 0) {
170 throw new IllegalArgumentException("Must specify a type");
171 }
172 return new PrimitiveRuleBuilder(rules, versions, new HashSet<>(Arrays.asList(type)));
173 }
174
175
176
177
178
179
180
181
182 public MessageRuleBuilder message(String eventType, String... triggerEvents) {
183 return new MessageRuleBuilder(rules, versions, eventType, triggerEvents);
184 }
185
186
187
188
189
190
191
192 public MessageExpressionBuilder message() {
193 return new MessageExpressionBuilder();
194 }
195
196
197
198
199
200
201
202 public EncodingRuleBuilder encoding(String encoding) {
203 return new EncodingRuleBuilder(rules, versions, encoding);
204 }
205
206
207
208
209
210
211 protected void addRuleBindings(T rule) {
212 if (Version.allVersions(versions)) {
213
214 rules.addAll(getRuleBindings(rule, "*"));
215 } else {
216 for (Version version : versions) {
217 rules.addAll(getRuleBindings(rule, version.getVersion()));
218 }
219 }
220 }
221
222
223
224
225
226
227
228
229
230 @SuppressWarnings("unchecked")
231 protected Collection<RuleBinding<T>> getRuleBindings(T rule, String version) {
232 return (Collection<RuleBinding<T>>) Collections.EMPTY_LIST;
233 }
234
235 protected Collection<RuleBinding<T>> activate(Collection<RuleBinding<T>> bindings) {
236 for (RuleBinding<T> ruleBinding : bindings) {
237 ruleBinding.setActive(active);
238 }
239 return bindings;
240 }
241
242
243 Set<Version> getVersions() {
244 return versions;
245 }
246
247
248
249
250 public class MessageExpressionBuilder {
251
252
253
254
255
256
257 public MessageRuleBuilder all() {
258 return new MessageRuleBuilder(rules, versions, "*", "*");
259 }
260
261
262
263
264
265
266
267 public MessageRuleBuilder allOfEventType(String eventType) {
268 return new MessageRuleBuilder(rules, versions, eventType, "*");
269 }
270
271
272
273
274
275
276
277
278 public MessageRuleBuilder rejectOtherThan(final String... triggerEvents) {
279 final Set<String> triggers = new HashSet<>(Arrays.asList(triggerEvents));
280 return all().test(new AbstractMessageRule() {
281 public ValidationException[] apply(Message message) {
282 try {
283 Terserrser.html#Terser">Terser t = new Terser(message);
284 String eventType = t.get("MSH-9-1");
285 String triggerEvent = t.get("MSH-9-2");
286 return triggers.contains(triggerEvent) ?
287 passed() :
288 failed(eventType + "^" + triggerEvent + " is not accepted");
289 } catch (HL7Exception e) {
290 return failed(e);
291 }
292 }
293 });
294
295 }
296
297 }
298 }