use of io.jans.scim.model.scim2.annotations.Attribute in project jans by JanssenProject.
the class Scim2PatchService method applyPatchOperation.
public BaseScimResource applyPatchOperation(BaseScimResource resource, PatchOperation operation, Predicate<String> selectionFilterSkipPredicate) throws Exception {
BaseScimResource result = null;
Map<String, Object> genericMap = null;
PatchOperationType opType = operation.getType();
Class<? extends BaseScimResource> clazz = resource.getClass();
String path = operation.getPath();
log.debug("applyPatchOperation of type {}", opType);
// Determine if operation is with value filter
if (StringUtils.isNotEmpty(path) && !operation.getType().equals(PatchOperationType.ADD)) {
Pair<Boolean, String> pair = validateBracketedPath(path);
if (pair.getFirst()) {
String valSelFilter = pair.getSecond();
if (valSelFilter == null) {
throw new SCIMException("Unexpected syntax in value selection filter");
} else {
int i = path.indexOf("[");
String attribute = path.substring(0, i);
i = path.lastIndexOf("].");
String subAttribute = i == -1 ? "" : path.substring(i + 2);
// Abort earlier
if (selectionFilterSkipPredicate.test(valSelFilter)) {
log.info("Patch operation will be skipped");
return resource;
} else {
return applyPatchOperationWithValueFilter(resource, operation, valSelFilter, attribute, subAttribute);
}
}
}
}
if (!opType.equals(PatchOperationType.REMOVE)) {
Object value = operation.getValue();
List<String> extensionUrns = extService.getUrnsOfExtensions(clazz);
if (value instanceof Map) {
genericMap = IntrospectUtil.strObjMap(value);
} else {
// It's an atomic value or an array
if (StringUtils.isEmpty(path)) {
throw new SCIMException("Value(s) supplied for resource not parseable");
}
// Create a simple map and trim the last part of path
String[] subPaths = ScimResourceUtil.splitPath(path, extensionUrns);
genericMap = Collections.singletonMap(subPaths[subPaths.length - 1], value);
if (subPaths.length == 1) {
path = "";
} else {
path = path.substring(0, path.lastIndexOf("."));
}
}
if (StringUtils.isNotEmpty(path)) {
// Visit backwards creating a composite map
String[] subPaths = ScimResourceUtil.splitPath(path, extensionUrns);
for (int i = subPaths.length - 1; i >= 0; i--) {
// Create a string consisting of all subpaths until the i-th
StringBuilder sb = new StringBuilder();
for (int j = 0; j <= i; j++) {
sb.append(subPaths[j]).append(".");
}
Attribute annot = IntrospectUtil.getFieldAnnotation(sb.substring(0, sb.length() - 1), clazz, Attribute.class);
boolean multivalued = !(annot == null || annot.multiValueClass().equals(NullType.class));
Map<String, Object> genericBiggerMap = new HashMap<>();
genericBiggerMap.put(subPaths[i], multivalued ? Collections.singletonList(genericMap) : genericMap);
genericMap = genericBiggerMap;
}
}
log.debug("applyPatchOperation. Generating a ScimResource from generic map: {}", genericMap.toString());
}
// Try parse genericMap as an instance of the resource
ObjectMapper mapper = new ObjectMapper();
BaseScimResource alter = opType.equals(PatchOperationType.REMOVE) ? resource : mapper.convertValue(genericMap, clazz);
List<Extension> extensions = extService.getResourceExtensions(clazz);
switch(operation.getType()) {
case REPLACE:
result = ScimResourceUtil.transferToResourceReplace(alter, resource, extensions);
break;
case ADD:
result = ScimResourceUtil.transferToResourceAdd(alter, resource, extensions);
break;
case REMOVE:
result = ScimResourceUtil.deleteFromResource(alter, operation.getPath(), extensions);
break;
}
return result;
}
use of io.jans.scim.model.scim2.annotations.Attribute in project jans by JanssenProject.
the class ResourceValidator method validateValidableAttributes.
/**
* Inspects the resource passed in the constructor and applies validations for every attribute annotated with
* {@link Validator}. Validations are of different nature as seen{@link Validations here}.
* @throws SCIMException When a validation does not pass (the {@link Validations#apply(Validations, Object) apply}
* method returns false)
*/
public void validateValidableAttributes() throws SCIMException {
Map<String, List<Method>> map = IntrospectUtil.validableCoreAttrs.get(resourceClass);
for (String attributePath : map.keySet()) {
Field f = IntrospectUtil.findFieldFromPath(resourceClass, attributePath);
Validations valToApply = f.getAnnotation(Validator.class).value();
log.debug("Validating value(s) of attribute '{}'", attributePath);
for (Object val : IntrospectUtil.getAttributeValues(resource, map.get(attributePath))) {
if (val != null && !Validations.apply(valToApply, val)) {
log.error("Error validating attribute '{}', wrong value supplied: '{}'", attributePath, val.toString());
throw new SCIMException(String.format(ATTR_VALIDATION_FAILED, attributePath));
}
}
}
}
use of io.jans.scim.model.scim2.annotations.Attribute in project jans by JanssenProject.
the class ResourceValidator method validateSchemasAttribute.
/**
* Inspects the {@link BaseScimResource#getSchemas() schemas} attribute of the resource passed in the constructor and
* checks the default schema <code>urn</code> associated to the resource type is present in the list. If some of the
* <code>urn</code>s part of the <code>Extension</code>s passed in the constructor are contained in the list, the validation is also
* successful.
* <p>This method should be called after a successful call to {@link #validateRequiredAttributes()}.</p>
* @throws SCIMException If there is no {@link BaseScimResource#getSchemas() schemas} in this resource or if some of
* the <code>urn</code>s there are not known.
*/
public void validateSchemasAttribute() throws SCIMException {
Set<String> schemaList = new HashSet<>(resource.getSchemas());
if (schemaList.isEmpty())
throw new SCIMException(WRONG_SCHEMAS_ATTR);
Set<String> allSchemas = new HashSet<>();
allSchemas.add(ScimResourceUtil.getDefaultSchemaUrn(resourceClass));
for (Extension ext : extensions) allSchemas.add(ext.getUrn());
schemaList.removeAll(allSchemas);
if (// means that some wrong extension urn is there
schemaList.size() > 0)
throw new SCIMException(WRONG_SCHEMAS_ATTR);
}
use of io.jans.scim.model.scim2.annotations.Attribute in project jans by JanssenProject.
the class ResourceValidator method validateCanonicalizedAttributes.
/**
* Inspects the resource passed in the constructor and for every attribute annotated with a non-empty collection of
* {@link Attribute#canonicalValues() canonical values}, it checks whether the attribute value matches any of the
* canonical values supplied.
* <p>This method should be called after a successful call to {@link #validateRequiredAttributes()}.</p>
* @throws SCIMException When a validation does not pass (there is no match for any of the attributes inspected)
*/
public void validateCanonicalizedAttributes() throws SCIMException {
Map<String, List<Method>> map = IntrospectUtil.canonicalCoreAttrs.get(resourceClass);
for (String attributePath : map.keySet()) {
Attribute attrAnnot = IntrospectUtil.getFieldAnnotation(attributePath, resourceClass, Attribute.class);
List<String> canonicalVals = Arrays.asList(attrAnnot.canonicalValues());
log.debug("Validating values of canonical attribute '{}'", attributePath);
for (Object val : IntrospectUtil.getAttributeValues(resource, map.get(attributePath))) {
if (!canonicalVals.contains(val.toString())) {
log.error("Error validating canonical attribute '{}', wrong value supplied: '{}'", attributePath, val.toString());
throw new SCIMException(String.format(ATTR_VALIDATION_FAILED, attributePath));
}
}
}
}
use of io.jans.scim.model.scim2.annotations.Attribute in project jans by JanssenProject.
the class ResourceValidator method validateExtendedAttributes.
/**
* Inspects the resource passed in the constructor and for every extended attribute (see {@link BaseScimResource#getCustomAttributes()},
* the attribute's value is checked to see if it complies with the data type it is supposed to belong to. This
* information is obtained from the list of <code>Extension</code>s passed in the constructor (every {@link ExtensionField}
* has an associated {@link ExtensionField#getType() type}.
* <p>When an attribute is {@link ExtensionField#isMultiValued() multi-valued}, every single item inside the collection
* is validated.</p>
* @throws SCIMException When any of the validations do not pass or an attribute seems not to be part of a known schema.
*/
public void validateExtendedAttributes() throws SCIMException {
// Note: throughout this method, we always ignore presence of nulls
// Gets all extended attributes (see the @JsonAnySetter annotation in BaseScimResource)
Map<String, Object> extendedAttributes = resource.getCustomAttributes();
// Iterate over every extension of the resource object (in practice it will be just one at most)
for (String schema : extendedAttributes.keySet()) {
// Validate if the schema referenced in the extended attributes is contained in the valid set of extension
Extension extension = null;
for (Extension ext : extensions) if (ext.getUrn().equals(schema)) {
extension = ext;
break;
}
if (extension != null) {
log.debug("validateExtendedAttributes. Revising attributes under schema {}", schema);
try {
// Obtains a generic map consisting of all name/value(s) pairs associated to this schema
Map<String, Object> attrsMap = IntrospectUtil.strObjMap(extendedAttributes.get(schema));
for (String attr : attrsMap.keySet()) {
Object value = attrsMap.get(attr);
if (value != null) {
/*
Gets the class associated to the value of current attribute. For extended attributes, we
should only see coming: String, Integer, Double, boolean, and Collection.
Different things will be rejected
*/
Class cls = value.getClass();
boolean isCollection = IntrospectUtil.isCollection(cls);
// If the attribute coming is unknown, NPE will be thrown and we are covered
log.debug("validateExtendedAttributes. Got value(s) for attribute '{}'", attr);
// Check if the multivalued custom attribute is consistent with the nature of the value itself
if (isCollection == extension.getFields().get(attr).isMultiValued()) {
if (isCollection) {
for (Object elem : (Collection) value) if (elem != null)
validateDataTypeExtendedAttr(extension, attr, elem);
} else
validateDataTypeExtendedAttr(extension, attr, value);
} else
throw new SCIMException(ERROR_PARSING_EXTENDED);
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
throw new SCIMException(ERROR_PARSING_EXTENDED);
}
} else
throw new SCIMException(String.format(UNKNOWN_EXTENSION, schema));
}
}
Aggregations