1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kew.docsearch.xml;
17
18 import com.google.common.base.Function;
19 import org.apache.commons.collections.CollectionUtils;
20 import org.apache.commons.lang.StringUtils;
21 import org.kuali.rice.core.api.search.Range;
22 import org.kuali.rice.core.api.search.SearchExpressionUtils;
23 import org.kuali.rice.core.api.uif.DataType;
24 import org.kuali.rice.core.api.uif.RemotableAbstractControl;
25 import org.kuali.rice.core.api.uif.RemotableAttributeError;
26 import org.kuali.rice.core.api.uif.RemotableAttributeField;
27 import org.kuali.rice.core.api.uif.RemotableAttributeLookupSettings;
28 import org.kuali.rice.core.api.uif.RemotableDatepicker;
29 import org.kuali.rice.core.api.uif.RemotableHiddenInput;
30 import org.kuali.rice.core.api.uif.RemotableQuickFinder;
31 import org.kuali.rice.core.api.uif.RemotableRadioButtonGroup;
32 import org.kuali.rice.core.api.uif.RemotableSelect;
33 import org.kuali.rice.core.api.uif.RemotableTextInput;
34 import org.kuali.rice.core.api.util.KeyValue;
35 import org.kuali.rice.core.framework.persistence.jdbc.sql.SQLUtils;
36 import org.kuali.rice.core.web.format.Formatter;
37 import org.kuali.rice.kew.api.KewApiConstants;
38 import org.kuali.rice.kew.api.WorkflowRuntimeException;
39 import org.kuali.rice.kew.api.document.DocumentWithContent;
40 import org.kuali.rice.kew.api.document.attribute.DocumentAttribute;
41 import org.kuali.rice.kew.api.document.attribute.WorkflowAttributeDefinition;
42 import org.kuali.rice.kew.api.document.search.DocumentSearchCriteria;
43 import org.kuali.rice.kew.api.extension.ExtensionDefinition;
44 import org.kuali.rice.kew.docsearch.CaseAwareSearchableAttributeValue;
45 import org.kuali.rice.kew.docsearch.DocumentSearchInternalUtils;
46 import org.kuali.rice.kew.docsearch.SearchableAttributeValue;
47 import org.kuali.rice.kew.framework.document.attribute.SearchableAttribute;
48 import org.kuali.rice.kew.rule.xmlrouting.XPathHelper;
49 import org.kuali.rice.kim.api.group.Group;
50 import org.kuali.rice.kim.api.group.GroupService;
51 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
52 import org.kuali.rice.kns.lookup.LookupUtils;
53 import org.kuali.rice.krad.UserSession;
54 import org.kuali.rice.krad.util.GlobalVariables;
55 import org.w3c.dom.Document;
56 import org.w3c.dom.Element;
57 import org.w3c.dom.NamedNodeMap;
58 import org.w3c.dom.Node;
59 import org.w3c.dom.NodeList;
60 import org.xml.sax.InputSource;
61
62 import javax.management.modelmbean.XMLParseException;
63 import javax.xml.parsers.DocumentBuilderFactory;
64 import javax.xml.parsers.ParserConfigurationException;
65 import javax.xml.xpath.XPath;
66 import javax.xml.xpath.XPathConstants;
67 import javax.xml.xpath.XPathExpressionException;
68 import java.io.BufferedReader;
69 import java.io.StringReader;
70 import java.util.ArrayList;
71 import java.util.Collection;
72 import java.util.Collections;
73 import java.util.HashMap;
74 import java.util.List;
75 import java.util.Map;
76 import java.util.regex.Matcher;
77 import java.util.regex.Pattern;
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 public class StandardGenericXMLSearchableAttribute implements SearchableAttribute {
138
139 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(StandardGenericXMLSearchableAttribute.class);
140 private static final String FIELD_DEF_E = "fieldDef";
141
142
143
144 private static final boolean PEDANTIC_BOUNDS_VALIDATION = true;
145
146
147 @Override
148 public String generateSearchContent(ExtensionDefinition extensionDefinition, String documentTypeName, WorkflowAttributeDefinition attributeDefinition) {
149 Map<String, String> propertyDefinitionMap = attributeDefinition.getPropertyDefinitionsAsMap();
150 try {
151 XMLSearchableAttributeContent content = new XMLSearchableAttributeContent(getConfigXML(extensionDefinition));
152 return content.generateSearchContent(propertyDefinitionMap);
153 } catch (XPathExpressionException e) {
154 LOG.error("error in getSearchContent ", e);
155 throw new RuntimeException("Error trying to find xml content with xpath expression", e);
156 } catch (Exception e) {
157 LOG.error("error in getSearchContent attempting to find xml search content", e);
158 throw new RuntimeException("Error trying to get xml search content.", e);
159 }
160 }
161
162 @Override
163 public List<DocumentAttribute> extractDocumentAttributes(ExtensionDefinition extensionDefinition, DocumentWithContent documentWithContent) {
164 List<DocumentAttribute> searchStorageValues = new ArrayList<DocumentAttribute>();
165 String fullDocumentContent = documentWithContent.getDocumentContent().getFullContent();
166 if (StringUtils.isBlank(documentWithContent.getDocumentContent().getFullContent())) {
167 LOG.warn("Empty Document Content found for document id: " + documentWithContent.getDocument().getDocumentId());
168 return searchStorageValues;
169 }
170 Document document;
171 try {
172 document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new BufferedReader(new StringReader(fullDocumentContent))));
173 } catch (Exception e){
174 LOG.error("error parsing docContent: "+documentWithContent.getDocumentContent(), e);
175 throw new RuntimeException("Error trying to parse docContent: "+documentWithContent.getDocumentContent(), e);
176 }
177 XMLSearchableAttributeContent content = new XMLSearchableAttributeContent(getConfigXML(extensionDefinition));
178 List<XMLSearchableAttributeContent.FieldDef> fields;
179 try {
180 fields = content.getFieldDefList();
181 } catch (XPathExpressionException xpee) {
182 throw new RuntimeException("Error parsing searchable attribute content", xpee);
183 } catch (ParserConfigurationException pce) {
184 throw new RuntimeException("Error parsing searchable attribute content", pce);
185 }
186 XPath xpath = XPathHelper.newXPath(document);
187 for (XMLSearchableAttributeContent.FieldDef field: fields) {
188 if (StringUtils.isNotEmpty(field.fieldEvaluationExpr)) {
189 List<String> values = new ArrayList<String>();
190 try {
191 NodeList searchValues = (NodeList) xpath.evaluate(field.fieldEvaluationExpr, document.getDocumentElement(), XPathConstants.NODESET);
192
193
194 for (int j = 0; j < searchValues.getLength(); j++) {
195 Node searchValue = searchValues.item(j);
196 if (searchValue.getFirstChild() != null && (StringUtils.isNotEmpty(searchValue.getFirstChild().getNodeValue()))) {
197 values.add(searchValue.getFirstChild().getNodeValue());
198 }
199 }
200 } catch (XPathExpressionException e) {
201 LOG.error("Error retrieving node set with expression: '" + field.fieldEvaluationExpr + "'. Trying string return type.", e);
202
203
204
205 try {
206 String searchValue = (String) xpath.evaluate(field.fieldEvaluationExpr, document.getDocumentElement(), XPathConstants.STRING);
207 if (StringUtils.isNotBlank(searchValue)) {
208 values.add(searchValue);
209 }
210 } catch (XPathExpressionException xpee) {
211 LOG.error("Error retrieving string with expression: '" + field.fieldEvaluationExpr + "'", xpee);
212 throw new RuntimeException("Error retrieving string with expression: '" + field.fieldEvaluationExpr + "'", xpee);
213 }
214 }
215
216
217 values.removeAll(Collections.singleton(null));
218
219
220 if (values.isEmpty()) {
221 values.add(null);
222 }
223 for (String value: values) {
224 DocumentAttribute searchableValue = this.setupSearchableAttributeValue(field.searchDefinition.dataType, field.name, value);
225 if (searchableValue != null) {
226 searchStorageValues.add(searchableValue);
227 }
228 }
229 }
230 }
231 return searchStorageValues;
232 }
233
234 private DocumentAttribute setupSearchableAttributeValue(String dataType, String key, String value) {
235 SearchableAttributeValue attValue = DocumentSearchInternalUtils.getSearchableAttributeValueByDataTypeString(dataType);
236 if (attValue == null) {
237 String errorMsg = "Cannot find a SearchableAttributeValue associated with the data type '" + dataType + "'";
238 LOG.error("setupSearchableAttributeValue() " + errorMsg);
239 throw new RuntimeException(errorMsg);
240 }
241 value = (value != null) ? value.trim() : null;
242 if ( (StringUtils.isNotBlank(value)) && (!attValue.isPassesDefaultValidation(value)) ) {
243 String errorMsg = "SearchableAttributeValue with the data type '" + dataType + "', key '" + key + "', and value '" + value + "' does not pass default validation and cannot be saved to the database";
244 LOG.error("setupSearchableAttributeValue() " + errorMsg);
245 throw new RuntimeException(errorMsg);
246 }
247 attValue.setSearchableAttributeKey(key);
248 attValue.setupAttributeValue(value);
249 return attValue.toDocumentAttribute();
250 }
251
252 @Override
253 public List<RemotableAttributeField> getSearchFields(ExtensionDefinition extensionDefinition, String documentTypeName) {
254 List<RemotableAttributeField> searchFields = new ArrayList<RemotableAttributeField>();
255 List<SearchableAttributeValue> searchableAttributeValues = DocumentSearchInternalUtils.getSearchableAttributeValueObjectTypes();
256
257 XMLSearchableAttributeContent content = new XMLSearchableAttributeContent(getConfigXML(extensionDefinition));
258 List<XMLSearchableAttributeContent.FieldDef> fields;
259 try {
260 fields = content.getFieldDefList();
261 } catch (XPathExpressionException xpee) {
262 throw new RuntimeException("Error parsing searchable attribute configuration", xpee);
263 } catch (ParserConfigurationException pce) {
264 throw new RuntimeException("Error parsing searchable attribute configuration", pce);
265 }
266 for (XMLSearchableAttributeContent.FieldDef field: fields) {
267 searchFields.add(convertFieldDef(field, searchableAttributeValues));
268 }
269
270 return searchFields;
271 }
272
273
274
275
276 private RemotableAttributeField convertFieldDef(XMLSearchableAttributeContent.FieldDef field, Collection<SearchableAttributeValue> searchableAttributeValues) {
277 RemotableAttributeField.Builder fieldBuilder = RemotableAttributeField.Builder.create(field.name);
278
279 fieldBuilder.setLongLabel(field.title);
280
281 RemotableAttributeLookupSettings.Builder attributeLookupSettings = RemotableAttributeLookupSettings.Builder.create();
282 fieldBuilder.setAttributeLookupSettings(attributeLookupSettings);
283
284
285 if (field.defaultValue != null) {
286 fieldBuilder.setDefaultValues(Collections.singletonList(field.defaultValue));
287 }
288
289
290 applyVisibility(fieldBuilder, attributeLookupSettings, field);
291
292
293 RemotableAbstractControl.Builder controlBuilder = constructControl(field.display.type, field.display.options);
294 fieldBuilder.setControl(controlBuilder);
295 if ("date".equals(field.display.type)) {
296 fieldBuilder.getWidgets().add(RemotableDatepicker.Builder.create());
297 fieldBuilder.setDataType(DataType.DATE);
298 }
299 if (!field.display.selectedOptions.isEmpty()) {
300 fieldBuilder.setDefaultValues(field.display.selectedOptions);
301 }
302
303
304 attributeLookupSettings.setInResults(field.isDisplayedInSearchResults());
305
306
307
308 DataType dataType = DocumentSearchInternalUtils.convertValueToDataType(field.searchDefinition.dataType);
309 fieldBuilder.setDataType(dataType);
310 if (DataType.DATE == fieldBuilder.getDataType()) {
311 fieldBuilder.getWidgets().add(RemotableDatepicker.Builder.create());
312 }
313
314 boolean isRangeSearchField = isRangeSearchField(searchableAttributeValues, fieldBuilder.getDataType(), field);
315 if (isRangeSearchField) {
316 attributeLookupSettings.setRanged(true);
317
318 attributeLookupSettings.setLowerBoundInclusive(field.searchDefinition.lowerBound.inclusive);
319 attributeLookupSettings.setUpperBoundInclusive(field.searchDefinition.upperBound.inclusive);
320 attributeLookupSettings.setLowerLabel(field.searchDefinition.lowerBound.label);
321 attributeLookupSettings.setUpperLabel(field.searchDefinition.upperBound.label);
322 attributeLookupSettings.setLowerDatePicker(field.searchDefinition.lowerBound.datePicker);
323 attributeLookupSettings.setUpperDatePicker(field.searchDefinition.upperBound.datePicker);
324 }
325
326 Boolean caseSensitive = field.searchDefinition.getRangeBoundOptions().caseSensitive;
327 if (caseSensitive != null) {
328 attributeLookupSettings.setCaseSensitive(caseSensitive);
329 }
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354 String formatter = field.display.formatter == null ? null : field.display.formatter;
355 fieldBuilder.setFormatterName(formatter);
356
357 try {
358
359 if(StringUtils.isNotEmpty(formatter)){
360 Formatter.registerFormatter(Class.forName(formatter), Class.forName(formatter));
361 }
362 } catch (ClassNotFoundException e) {
363 LOG.error("Unable to find formatter class: " + formatter);
364 throw new RuntimeException("Unable to find formatter class: " + formatter);
365 }
366
367
368
369
370 if (field.lookup.dataObjectClass != null) {
371 RemotableQuickFinder.Builder quickFinderBuilder = RemotableQuickFinder.Builder.create(LookupUtils.getBaseLookupUrl(false), field.lookup.dataObjectClass);
372 quickFinderBuilder.setFieldConversions(field.lookup.fieldConversions);
373 fieldBuilder.getWidgets().add(quickFinderBuilder);
374 }
375
376 return fieldBuilder.build();
377 }
378
379
380
381
382
383
384
385
386 private boolean isRangeSearchField(Collection<SearchableAttributeValue> searchableAttributeValues, DataType dataType, XMLSearchableAttributeContent.FieldDef field) {
387 for (SearchableAttributeValue attValue : searchableAttributeValues)
388 {
389 DataType attributeValueDataType = DocumentSearchInternalUtils.convertValueToDataType(attValue.getAttributeDataType());
390 if (attributeValueDataType == dataType) {
391 return isRangeSearchField(attValue, field);
392 }
393 }
394 String errorMsg = "Could not find searchable attribute value for data type '" + dataType + "'";
395 LOG.error("isRangeSearchField(List, String, NamedNodeMap, Node) " + errorMsg);
396 throw new WorkflowRuntimeException(errorMsg);
397 }
398
399 private boolean isRangeSearchField(SearchableAttributeValue searchableAttributeValue, XMLSearchableAttributeContent.FieldDef field) {
400
401
402 boolean allowRangedSearch = searchableAttributeValue.allowsRangeSearches();
403
404
405 return allowRangedSearch && field.searchDefinition.isRangedSearch();
406 }
407
408
409
410
411 private void applyVisibility(RemotableAttributeField.Builder fieldBuilder, RemotableAttributeLookupSettings.Builder attributeLookupSettings, XMLSearchableAttributeContent.FieldDef field) {
412 boolean visible = true;
413
414 if (field.visibility.visible != null) {
415 visible = field.visibility.visible;
416 } else {
417 if (field.visibility.groupName != null) {
418 UserSession session = GlobalVariables.getUserSession();
419 if (session == null) {
420 throw new WorkflowRuntimeException("UserSession is null! Attempted to render the searchable attribute outside of an established session.");
421 }
422 GroupService groupService = KimApiServiceLocator.getGroupService();
423
424 Group group = groupService.getGroupByNamespaceCodeAndName(field.visibility.groupNamespace, field.visibility.groupName);
425 visible = group == null ? false : groupService.isMemberOfGroup(session.getPerson().getPrincipalId(), group.getId());
426 }
427 }
428 String type = field.visibility.type;
429 if ("field".equals(type) || "fieldAndColumn".equals(type)) {
430
431 if (!visible) {
432 fieldBuilder.setControl(RemotableHiddenInput.Builder.create());
433 }
434 }
435 if ("column".equals(type) || "fieldAndColumn".equals(type)) {
436 attributeLookupSettings.setInCriteria(visible);
437 }
438 }
439
440 private RemotableAbstractControl.Builder constructControl(String type, Collection<KeyValue> options) {
441 RemotableAbstractControl.Builder control = null;
442 Map<String, String> optionMap = new HashMap<String, String>();
443 for (KeyValue option : options) {
444 optionMap.put(option.getKey(), option.getValue());
445 }
446 if ("text".equals(type) || "date".equals(type)) {
447 control = RemotableTextInput.Builder.create();
448 } else if ("select".equals(type)) {
449 control = RemotableSelect.Builder.create(optionMap);
450 } else if ("radio".equals(type)) {
451 control = RemotableRadioButtonGroup.Builder.create(optionMap);
452 } else if ("hidden".equals(type)) {
453 control = RemotableHiddenInput.Builder.create();
454 } else if ("multibox".equals(type)) {
455 RemotableSelect.Builder builder = RemotableSelect.Builder.create(optionMap);
456 builder.setMultiple(true);
457 control = builder;
458 } else {
459 throw new IllegalArgumentException("Illegal field type found: " + type);
460 }
461 return control;
462 }
463
464 @Override
465 public List<RemotableAttributeError> validateDocumentAttributeCriteria(ExtensionDefinition extensionDefinition, DocumentSearchCriteria documentSearchCriteria) {
466 List<RemotableAttributeError> errors = new ArrayList<RemotableAttributeError>();
467
468 Map<String, List<String>> documentAttributeValues = documentSearchCriteria.getDocumentAttributeValues();
469 if (documentAttributeValues == null || documentAttributeValues.isEmpty()) {
470
471 return errors;
472 }
473
474 XMLSearchableAttributeContent content = new XMLSearchableAttributeContent(getConfigXML(extensionDefinition));
475 List<XMLSearchableAttributeContent.FieldDef> fields;
476 try {
477 fields = content.getFieldDefList();
478 } catch (XPathExpressionException xpee) {
479 throw new RuntimeException("Error parsing searchable attribute configuration", xpee);
480 } catch (ParserConfigurationException pce) {
481 throw new RuntimeException("Error parsing searchable attribute configuration", pce);
482 }
483 if (fields.isEmpty()) {
484 LOG.warn("Could not find any field definitions (<" + FIELD_DEF_E + ">) or possibly a searching configuration (<searchingConfig>) for this XMLSearchAttribute");
485 return errors;
486 }
487
488 for (XMLSearchableAttributeContent.FieldDef field: fields) {
489 String fieldDefName = field.name;
490 String fieldDefTitle = field.title == null ? "" : field.title;
491
492 List<String> testObject = documentAttributeValues.get(fieldDefName);
493
494 if (testObject == null || testObject.isEmpty()) {
495
496
497 continue;
498 }
499
500
501
502 SearchableAttributeValue attributeValue = DocumentSearchInternalUtils.getSearchableAttributeValueByDataTypeString(field.searchDefinition.dataType);
503 if (attributeValue == null) {
504 String errorMsg = "Cannot find SearchableAttributeValue for field data type '" + field.searchDefinition.dataType + "'";
505 LOG.error("validateUserSearchInputs() " + errorMsg);
506 throw new RuntimeException(errorMsg);
507 }
508
509
510
511
512
513 List<String> terminalValues = new ArrayList<String>();
514 List<Range> rangeValues = new ArrayList<Range>();
515
516
517
518
519
520 for (String value: testObject) {
521
522 if (value == null) {
523
524 continue;
525 }
526
527 String[] clauses = SearchExpressionUtils.splitOnClauses(value);
528 for (String clause: clauses) {
529
530 Range r = null;
531 if (StringUtils.isNotEmpty(value)) {
532 r = SearchExpressionUtils.parseRange(value);
533 }
534 if (r != null) {
535
536 boolean errs = false;
537 if (!field.searchDefinition.isRangedSearch()) {
538 errs = true;
539 errors.add(RemotableAttributeError.Builder.create(field.name, "field does not support ranged searches but range search expression detected").build());
540 } else {
541
542
543 if (PEDANTIC_BOUNDS_VALIDATION) {
544
545
546
547
548
549 if (r.getLowerBoundValue() != null && r.isLowerBoundInclusive() != field.searchDefinition.lowerBound.inclusive) {
550 errs = true;
551 errors.add(RemotableAttributeError.Builder.create(field.name, "range expression ('" + value + "') and attribute definition differ on lower bound inclusivity. Range is: " + r.isLowerBoundInclusive() + " Attrib is: " + field.searchDefinition.lowerBound.inclusive).build());
552 }
553 if (r.getUpperBoundValue() != null && r.isUpperBoundInclusive() != field.searchDefinition.upperBound.inclusive) {
554 errs = true;
555 errors.add(RemotableAttributeError.Builder.create(field.name, "range expression ('" + value + "') and attribute definition differ on upper bound inclusivity. Range is: " + r.isUpperBoundInclusive() + " Attrib is: " + field.searchDefinition.upperBound.inclusive).build());
556 }
557 }
558 }
559
560 if (!errs) {
561 rangeValues.add(r);
562 }
563 } else {
564 terminalValues.add(value);
565 }
566 }
567 }
568
569 List<String> parsedValues = new ArrayList<String>();
570
571 for (String value: terminalValues) {
572 errors.addAll(performValidation(attributeValue, field, value, fieldDefTitle, parsedValues));
573 }
574 for (Range range: rangeValues) {
575 List<String> parsedLowerValues = new ArrayList<String>();
576 List<String> parsedUpperValues = new ArrayList<String>();
577 List<RemotableAttributeError> lowerErrors = performValidation(attributeValue, field,
578 range.getLowerBoundValue(), constructRangeFieldErrorPrefix(field.title,
579 field.searchDefinition.lowerBound), parsedLowerValues);
580 errors.addAll(lowerErrors);
581 List<RemotableAttributeError> upperErrors = performValidation(attributeValue, field, range.getUpperBoundValue(),
582 constructRangeFieldErrorPrefix(field.title, field.searchDefinition.upperBound), parsedUpperValues);
583 errors.addAll(upperErrors);
584
585
586 if (lowerErrors.isEmpty() && upperErrors.isEmpty()) {
587
588 String lowerBoundValue = parsedLowerValues.isEmpty() ? null : parsedLowerValues.get(0);
589 String upperBoundValue = parsedUpperValues.isEmpty() ? null : parsedUpperValues.get(0);
590
591 final Boolean rangeValid;
592
593
594 if (KewApiConstants.SearchableAttributeConstants.DATA_TYPE_STRING.equals(field.searchDefinition.dataType)) {
595 boolean caseSensitive = field.searchDefinition.getRangeBoundOptions().caseSensitive == null ? true : field.searchDefinition.getRangeBoundOptions().caseSensitive;
596 rangeValid = ((CaseAwareSearchableAttributeValue) attributeValue).isRangeValid(lowerBoundValue, upperBoundValue, caseSensitive);
597 } else {
598 rangeValid = attributeValue.isRangeValid(lowerBoundValue, upperBoundValue);
599 }
600
601 if (rangeValid != null && !rangeValid) {
602 String errorMsg = "The " + fieldDefTitle + " range is incorrect. The " +
603 (StringUtils.isNotBlank(field.searchDefinition.lowerBound.label) ? field.searchDefinition.lowerBound.label : KewApiConstants.SearchableAttributeConstants.DEFAULT_RANGE_SEARCH_LOWER_BOUND_LABEL)
604 + " value entered must come before the " +
605 (StringUtils.isNotBlank(field.searchDefinition.upperBound.label) ? field.searchDefinition.upperBound.label : KewApiConstants.SearchableAttributeConstants.DEFAULT_RANGE_SEARCH_UPPER_BOUND_LABEL)
606 + " value";
607 LOG.debug("validateUserSearchInputs() " + errorMsg + " :: field type '" + attributeValue.getAttributeDataType() + "'");
608 errors.add(RemotableAttributeError.Builder.create(fieldDefName, errorMsg).build());
609 }
610 }
611 }
612 }
613 return errors;
614 }
615
616 private String constructRangeFieldErrorPrefix(String fieldDefLabel, XMLSearchableAttributeContent.FieldDef.SearchDefinition.RangeBound rangeBound) {
617 if ( StringUtils.isNotBlank(rangeBound.label) && StringUtils.isNotBlank(fieldDefLabel)) {
618 return fieldDefLabel + " " + rangeBound.label + " Field";
619 } else if (StringUtils.isNotBlank(fieldDefLabel)) {
620 return fieldDefLabel + " Range Field";
621 } else if (StringUtils.isNotBlank(rangeBound.label)) {
622 return "Range Field " + rangeBound.label + " Field";
623 }
624 return null;
625 }
626
627
628
629
630
631
632
633
634
635
636 private List<RemotableAttributeError> performValidation(SearchableAttributeValue attributeValue, final XMLSearchableAttributeContent.FieldDef field, String enteredValue, String errorMessagePrefix, List<String> resultingValues) {
637 return DocumentSearchInternalUtils.validateSearchFieldValue(field.name, attributeValue, enteredValue, errorMessagePrefix, resultingValues, new Function<String, Collection<RemotableAttributeError>>() {
638 @Override
639 public Collection<RemotableAttributeError> apply(String value) {
640 if (StringUtils.isNotEmpty(field.validation.regex)) {
641 Pattern pattern = Pattern.compile(field.validation.regex);
642 Matcher matcher = pattern.matcher(value);
643 if (!matcher.matches()) {
644 return Collections.singletonList(RemotableAttributeError.Builder.create(field.name, field.validation.message).build());
645 }
646 }
647 return Collections.emptyList();
648 }
649 });
650 }
651
652
653 protected Element getConfigXML(ExtensionDefinition extensionDefinition) {
654 try {
655 String xmlConfigData = extensionDefinition.getConfiguration().get(KewApiConstants.ATTRIBUTE_XML_CONFIG_DATA);
656 return DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(new BufferedReader(new StringReader(xmlConfigData)))).getDocumentElement();
657 } catch (Exception e) {
658 String ruleAttrStr = (extensionDefinition == null ? null : extensionDefinition.getName());
659 LOG.error("error parsing xml data from search attribute: " + ruleAttrStr, e);
660 throw new RuntimeException("error parsing xml data from searchable attribute: " + ruleAttrStr, e);
661 }
662 }
663 }