@Override public void validate(final String value, final PlainAttrValue attrValue) { attrValue.parseValue(schema, value); doValidate(attrValue); }
@Override public <T extends PlainAttrValue> T clonePlainAttrValue(final T src) { T dst; if (src instanceof PlainAttrUniqueValue) { dst = newPlainAttrUniqueValue(); } else { dst = newPlainAttrValue(); } dst.setBinaryValue(src.getBinaryValue()); dst.setBooleanValue(src.getBooleanValue()); dst.setDateValue(src.getDateValue()); dst.setDoubleValue(src.getDoubleValue()); dst.setLongValue(src.getLongValue()); dst.setStringValue(src.getStringValue()); return dst; }
public InvalidPlainAttrValueException(final PlainAttrValue value, final Throwable cause) { this("Could not validate " + value.getValue(), cause); } }
@Override protected void doValidate(final PlainAttrValue attrValue) { try { new URL(attrValue.getStringValue()); } catch (MalformedURLException e) { throw new InvalidPlainAttrValueException("\"" + attrValue.getValue() + "\" is not a valid URL"); } } }
@Override public List<PlainAttrValue> beforePropagation( final Item item, final Entity entity, final List<PlainAttrValue> values) { if (StringUtils.isNotBlank(propagationJEXL) && values != null) { values.forEach(value -> { Object originalValue = value.getValue(); if (originalValue != null) { JexlContext jexlContext = new MapContext(); if (entity != null) { JexlUtils.addFieldsToContext(entity, jexlContext); if (entity instanceof Any) { JexlUtils.addPlainAttrsToContext(((Any<?>) entity).getPlainAttrs(), jexlContext); JexlUtils.addDerAttrsToContext(((Any<?>) entity), jexlContext); } } jexlContext.set("value", originalValue.toString()); value.setBinaryValue(null); value.setBooleanValue(null); value.setDateValue(null); value.setDoubleValue(null); value.setLongValue(null); value.setStringValue(JexlUtils.evaluate(propagationJEXL, jexlContext)); } }); return values; } return JEXLItemTransformer.super.beforePropagation(item, entity, values); }
value.setStringValue(transformed); } else { try { value.parseValue(schema, transformed); } catch (ParsingValidationException e) { LOG.error("While parsing provided key value {}", transformed, e); value.setStringValue(transformed);
attrValue.setStringValue(reference.getKey()); values.add(attrValue); break; attrValue.setStringValue(reference.getRealm().getFullPath()); values.add(attrValue); break; attrValue.setStringValue(groupOwnerValue); values.add(attrValue); attrValue.setBooleanValue(((User) reference).isSuspended()); values.add(attrValue); attrValue.setBooleanValue(((User) reference).isMustChangePassword()); values.add(attrValue); attrValue.setStringValue(DateFormatUtils.ISO_8601_EXTENDED_DATETIME_TIME_ZONE_FORMAT. format((Date) fieldValue)); } else if (Boolean.TYPE.isInstance(fieldValue)) { attrValue.setBooleanValue((Boolean) fieldValue); } else if (Double.TYPE.isInstance(fieldValue) || Float.TYPE.isInstance(fieldValue)) { attrValue.setDoubleValue((Double) fieldValue); } else if (Long.TYPE.isInstance(fieldValue) || Integer.TYPE.isInstance(fieldValue)) { attrValue.setLongValue((Long) fieldValue); } else { attrValue.setStringValue(fieldValue.toString()); if (derValue != null) {
objValues.add(value.getValue()); } else { if (schema instanceof PlainSchema) { objValues.add(value.getValueAsString((PlainSchema) schema)); } else { objValues.add(value.getValueAsString(schemaType));
@Override public List<String> getValuesAsStrings() { List<String> result; if (getUniqueValue() == null) { result = getValues().stream().map(value -> value.getValueAsString()).collect(Collectors.toList()); } else { result = Collections.singletonList(getUniqueValue().getValueAsString()); } return Collections.unmodifiableList(result); }
value.setStringValue(transformed); } else { try { value.parseValue(schema, transformed); } catch (ParsingValidationException e) { LOG.error("While parsing provided key value {}", transformed, e); value.setStringValue(transformed);
@Transactional(readOnly = true) @Override public Optional<String> getConnObjectKeyValue(final Any<?> any, final Provision provision) { MappingItem mapItem = provision.getMapping().getConnObjectKeyItem().get(); List<PlainAttrValue> values; try { values = getIntValues( provision, mapItem, intAttrNameParser.parse(mapItem.getIntAttrName(), provision.getAnyType().getKind()), any); } catch (ParseException e) { LOG.error("Invalid intAttrName '{}' specified, ignoring", mapItem.getIntAttrName(), e); values = Collections.emptyList(); } return Optional.ofNullable(values.isEmpty() ? null : values.get(0).getValueAsString()); }
value.setStringValue(connObjectKey); } else { try { value.parseValue(schema, connObjectKey); } catch (ParsingValidationException e) { LOG.error("While parsing provided __UID__ {}", value, e); value.setStringValue(connObjectKey);
public InvalidPlainAttrValueException(final PlainAttrValue value) { this("Could not validate " + value.getValue()); }
@Override protected void doValidate(final PlainAttrValue attrValue) { Matcher matcher = SyncopeConstants.EMAIL_PATTERN.matcher(attrValue.<CharSequence>getValue()); if (!matcher.matches()) { throw new InvalidPlainAttrValueException("\"" + attrValue.getValue() + "\" is not a valid email address"); } } }
@Override protected void doValidate(final PlainAttrValue attrValue) { Boolean value = attrValue.getValue(); if (!value) { throw new InvalidPlainAttrValueException("This attribute must be set to \"true\""); } } }
query.append("LOWER(?").append(setParameter(parameters, attrValue.getValue())).append(')'); } else { query.append('?').append(setParameter(parameters, attrValue.getValue())); query.append(">="); query.append('?').append(setParameter(parameters, attrValue.getValue())); break; query.append('>'); query.append('?').append(setParameter(parameters, attrValue.getValue())); break; query.append("<="); query.append('?').append(setParameter(parameters, attrValue.getValue())); break; query.append('<'); query.append('?').append(setParameter(parameters, attrValue.getValue())); break;