protected Optional parseNode()

in core/persistence-neo4j/src/main/java/org/apache/syncope/core/persistence/neo4j/content/ContentLoaderHandler.java [168:251]
79 lines of code
29 McCabe index (conditional complexity)

    protected Optional<Node> parseNode(final NodeDescription<?> nodeDesc, final Attributes atts) {
        String id = null;
        Map<String, Object> props = new HashMap<>();
        for (int i = 0; i < atts.getLength(); i++) {
            String originalName = atts.getQName(i);
            String originalValue = atts.getValue(i);

            if ("id".equalsIgnoreCase(originalName)) {
                id = originalValue;
                props.put("id", originalValue);
            } else {
                String name = nodeDesc.getGraphProperties().stream().
                        map(GraphPropertyDescription::getPropertyName).
                        filter(propertyName -> propertyName.equalsIgnoreCase(originalName)).
                        findFirst().orElseGet(() -> originalName.startsWith("plainAttrs.") ? originalName : null);
                if (name == null) {
                    LOG.error("Property {} not matching for {}", originalName, nodeDesc.getPrimaryLabel());
                    continue;
                }

                Class<?> type = nodeDesc.getGraphProperties().stream().
                        filter(prop -> prop.getPropertyName().equalsIgnoreCase(name)).
                        findFirst().map(GraphPropertyDescription::getActualType).
                        orElseGet(() -> {
                            if (!name.startsWith("plainAttrs.")) {
                                LOG.warn("No type found for property {}#{}", nodeDesc.getPrimaryLabel(), name);
                            }
                            return String.class;
                        });

                String value = paramSubstitutor.replace(atts.getValue(i));
                if (value == null) {
                    LOG.warn("Variable ${} could not be resolved", atts.getValue(i));
                    value = atts.getValue(i);
                }
                value = StringEscapeUtils.unescapeXml(value);

                if (int.class.isAssignableFrom(type) || Integer.class.isAssignableFrom(type)) {
                    try {
                        props.put(name, Integer.valueOf(value));
                    } catch (NumberFormatException e) {
                        LOG.error("Unparsable Integer '{}'", value);
                    }
                } else if (long.class.isAssignableFrom(type) || Long.class.isAssignableFrom(type)) {
                    try {
                        props.put(name, Long.valueOf(value));
                    } catch (NumberFormatException e) {
                        LOG.error("Unparsable Long '{}'", value);
                    }
                } else if (float.class.isAssignableFrom(type) || Float.class.isAssignableFrom(type)) {
                    try {
                        props.put(name, Float.valueOf(value));
                    } catch (NumberFormatException e) {
                        LOG.error("Unparsable Float '{}'", value);
                    }
                } else if (double.class.isAssignableFrom(type) || Double.class.isAssignableFrom(type)) {
                    try {
                        props.put(name, Double.valueOf(value));
                    } catch (NumberFormatException e) {
                        LOG.error("Unparsable Double '{}'", value);
                    }
                } else if (Date.class.isAssignableFrom(type) || OffsetDateTime.class.isAssignableFrom(type)) {
                    try {
                        props.put(name, FormatUtils.parseDate(value));
                    } catch (DateTimeParseException e) {
                        LOG.error("Unparsable Date '{}'", value);
                    }
                } else if (boolean.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type)) {
                    props.put(name, "1".equals(value) ? Boolean.TRUE : Boolean.FALSE);
                } else if (byte[].class.isAssignableFrom(type)) {
                    try {
                        props.put(name, DatatypeConverter.parseHexBinary(value));
                    } catch (IllegalArgumentException e) {
                        LOG.warn("Error decoding hex string to specify a blob parameter", e);
                    }
                }
                if (!props.containsKey(name)) {
                    props.put(name, value);
                }
            }
        }

        return id == null ? Optional.empty() : Optional.of(new Node(id, props));
    }