Example usage for com.fasterxml.jackson.databind.node ArrayNode size

List of usage examples for com.fasterxml.jackson.databind.node ArrayNode size

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.databind.node.*
  5. ArrayNode
  6. size

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.node ArrayNode size.

Prototype

public int size()

Source Link

Usage

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public String inferTypeFromArray(ArrayNode an) {
    if (an.size() == 0) {
        return "string";
    }/*from   w  ww .ja  v a2 s.  c o  m*/
    String type = null;
    for (int i = 0; i < an.size(); i++) {
        JsonNode element = an.get(0);
        if (element.isBoolean()) {
            if (type == null) {
                type = "boolean";
            } else if (!"boolean".equals(type)) {
                type = "string";
            }
        } else if (element.isNumber()) {
            if (type == null) {
                type = "number";
            } else if (!"number".equals(type)) {
                type = "string";
            }
        } else {
            type = "string";
        }
    }

    return type;
}

From source file:com.funtl.framework.smoke.core.modules.act.rest.diagram.services.BaseProcessDefinitionDiagramLayoutResource.java

public ObjectNode getDiagramNode(String processInstanceId, String processDefinitionId) {

    List<String> highLightedFlows = Collections.<String>emptyList();
    List<String> highLightedActivities = Collections.<String>emptyList();

    Map<String, ObjectNode> subProcessInstanceMap = new HashMap<String, ObjectNode>();

    ProcessInstance processInstance = null;
    if (processInstanceId != null) {
        processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId)
                .singleResult();//from  w  w  w. ja va 2 s .c om
        if (processInstance == null) {
            throw new ActivitiObjectNotFoundException("Process instance could not be found");
        }
        processDefinitionId = processInstance.getProcessDefinitionId();

        List<ProcessInstance> subProcessInstances = runtimeService.createProcessInstanceQuery()
                .superProcessInstanceId(processInstanceId).list();

        for (ProcessInstance subProcessInstance : subProcessInstances) {
            String subDefId = subProcessInstance.getProcessDefinitionId();

            String superExecutionId = ((ExecutionEntity) subProcessInstance).getSuperExecutionId();
            ProcessDefinitionEntity subDef = (ProcessDefinitionEntity) repositoryService
                    .getProcessDefinition(subDefId);

            ObjectNode processInstanceJSON = new ObjectMapper().createObjectNode();
            processInstanceJSON.put("processInstanceId", subProcessInstance.getId());
            processInstanceJSON.put("superExecutionId", superExecutionId);
            processInstanceJSON.put("processDefinitionId", subDef.getId());
            processInstanceJSON.put("processDefinitionKey", subDef.getKey());
            processInstanceJSON.put("processDefinitionName", subDef.getName());

            subProcessInstanceMap.put(superExecutionId, processInstanceJSON);
        }
    }

    if (processDefinitionId == null) {
        throw new ActivitiObjectNotFoundException("No process definition id provided");
    }

    ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) repositoryService
            .getProcessDefinition(processDefinitionId);

    if (processDefinition == null) {
        throw new ActivitiException("Process definition " + processDefinitionId + " could not be found");
    }

    ObjectNode responseJSON = new ObjectMapper().createObjectNode();

    // Process definition
    JsonNode pdrJSON = getProcessDefinitionResponse(processDefinition);

    if (pdrJSON != null) {
        responseJSON.set("processDefinition", pdrJSON);
        //         responseJSON.put("processDefinition", pdrJSON); //  - 2016-09-03 by Lusifer
    }

    // Highlighted activities
    if (processInstance != null) {
        ArrayNode activityArray = new ObjectMapper().createArrayNode();
        ArrayNode flowsArray = new ObjectMapper().createArrayNode();

        highLightedActivities = runtimeService.getActiveActivityIds(processInstanceId);
        highLightedFlows = getHighLightedFlows(processInstanceId, processDefinition);

        for (String activityName : highLightedActivities) {
            activityArray.add(activityName);
        }

        for (String flow : highLightedFlows)
            flowsArray.add(flow);

        responseJSON.set("highLightedActivities", activityArray);
        responseJSON.set("highLightedFlows", flowsArray);

        //         responseJSON.put("highLightedActivities", activityArray); //  - 2016-09-03 by Lusifer
        //         responseJSON.put("highLightedFlows", flowsArray); //  - 2016-09-03 by Lusifer
    }

    // Pool shape, if process is participant in collaboration
    if (processDefinition.getParticipantProcess() != null) {
        ParticipantProcess pProc = processDefinition.getParticipantProcess();

        ObjectNode participantProcessJSON = new ObjectMapper().createObjectNode();
        participantProcessJSON.put("id", pProc.getId());
        if (StringUtils.isNotEmpty(pProc.getName())) {
            participantProcessJSON.put("name", pProc.getName());
        } else {
            participantProcessJSON.put("name", "");
        }
        participantProcessJSON.put("x", pProc.getX());
        participantProcessJSON.put("y", pProc.getY());
        participantProcessJSON.put("width", pProc.getWidth());
        participantProcessJSON.put("height", pProc.getHeight());

        responseJSON.set("participantProcess", participantProcessJSON);
        //         responseJSON.put("participantProcess", participantProcessJSON); //  - 2016-09-03 by Lusifer
    }

    // Draw lanes

    if (processDefinition.getLaneSets() != null && !processDefinition.getLaneSets().isEmpty()) {
        ArrayNode laneSetArray = new ObjectMapper().createArrayNode();
        for (LaneSet laneSet : processDefinition.getLaneSets()) {
            ArrayNode laneArray = new ObjectMapper().createArrayNode();
            if (laneSet.getLanes() != null && !laneSet.getLanes().isEmpty()) {
                for (Lane lane : laneSet.getLanes()) {
                    ObjectNode laneJSON = new ObjectMapper().createObjectNode();
                    laneJSON.put("id", lane.getId());
                    if (StringUtils.isNotEmpty(lane.getName())) {
                        laneJSON.put("name", lane.getName());
                    } else {
                        laneJSON.put("name", "");
                    }
                    laneJSON.put("x", lane.getX());
                    laneJSON.put("y", lane.getY());
                    laneJSON.put("width", lane.getWidth());
                    laneJSON.put("height", lane.getHeight());

                    List<String> flowNodeIds = lane.getFlowNodeIds();
                    ArrayNode flowNodeIdsArray = new ObjectMapper().createArrayNode();
                    for (String flowNodeId : flowNodeIds) {
                        flowNodeIdsArray.add(flowNodeId);
                    }
                    laneJSON.set("flowNodeIds", flowNodeIdsArray);
                    //                  laneJSON.put("flowNodeIds", flowNodeIdsArray); //  - 2016-09-03 by Lusifer

                    laneArray.add(laneJSON);
                }
            }
            ObjectNode laneSetJSON = new ObjectMapper().createObjectNode();
            laneSetJSON.put("id", laneSet.getId());
            if (StringUtils.isNotEmpty(laneSet.getName())) {
                laneSetJSON.put("name", laneSet.getName());
            } else {
                laneSetJSON.put("name", "");
            }
            laneSetJSON.set("lanes", laneArray);
            //            laneSetJSON.put("lanes", laneArray); //  - 2016-09-03 by Lusifer

            laneSetArray.add(laneSetJSON);
        }

        if (laneSetArray.size() > 0)
            responseJSON.set("laneSets", laneSetArray);
        //            responseJSON.put("laneSets", laneSetArray); //  - 2016-09-03 by Lusifer
    }

    ArrayNode sequenceFlowArray = new ObjectMapper().createArrayNode();
    ArrayNode activityArray = new ObjectMapper().createArrayNode();

    // Activities and their sequence-flows

    for (ActivityImpl activity : processDefinition.getActivities()) {
        getActivity(processInstanceId, activity, activityArray, sequenceFlowArray, processInstance,
                highLightedFlows, subProcessInstanceMap);
    }

    responseJSON.set("activities", activityArray);
    responseJSON.set("sequenceFlows", sequenceFlowArray);
    //      responseJSON.put("activities", activityArray); //  - 2016-09-03 by Lusifer
    //      responseJSON.put("sequenceFlows", sequenceFlowArray); //  - 2016-09-03 by Lusifer

    return responseJSON;
}

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public OpenAPI parseRoot(JsonNode node, ParseResult result, String path) {
    String location = "";
    OpenAPI openAPI = new OpenAPI();
    if (node.getNodeType().equals(JsonNodeType.OBJECT)) {
        ObjectNode rootNode = (ObjectNode) node;

        // required
        String value = getString("openapi", rootNode, true, location, result);

        // we don't even try if the version isn't there
        if (value == null || !value.startsWith("3.0")) {
            return null;
        }//w  w w .j  a va2s.  com
        openAPI.setOpenapi(value);

        ObjectNode obj = getObject("info", rootNode, true, location, result);
        if (obj != null) {
            Info info = getInfo(obj, "info", result);
            openAPI.setInfo(info);
        }

        obj = getObject("paths", rootNode, true, location, result);
        if (obj != null) {
            Paths paths = getPaths(obj, "paths", result);
            openAPI.setPaths(paths);
        }

        obj = getObject("components", rootNode, false, location, result);
        if (obj != null) {
            Components components = getComponents(obj, "components", result);
            openAPI.setComponents(components);
        }

        ArrayNode array = getArray("servers", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            openAPI.setServers(
                    getServersList(array, String.format("%s.%s", location, "servers"), result, path));
        } else {
            Server defaultServer = new Server();
            defaultServer.setUrl("/");
            List<Server> servers = new ArrayList<>();
            servers.add(defaultServer);
            openAPI.setServers(servers);
        }

        obj = getObject("externalDocs", rootNode, false, location, result);
        if (obj != null) {
            ExternalDocumentation externalDocs = getExternalDocs(obj, "externalDocs", result);
            openAPI.setExternalDocs(externalDocs);
        }

        array = getArray("tags", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            openAPI.setTags(getTagList(array, "tags", result));
        }

        array = getArray("security", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            List<SecurityRequirement> securityRequirements = getSecurityRequirementsList(array, "security",
                    result);
            if (securityRequirements != null && securityRequirements.size() > 0) {
                openAPI.setSecurity(securityRequirements);
            }
        }

        Map<String, Object> extensions = getExtensions(rootNode);
        if (extensions != null && extensions.size() > 0) {
            openAPI.setExtensions(extensions);
        }

        Set<String> keys = getKeys(rootNode);
        for (String key : keys) {
            if (!ROOT_KEYS.contains(key) && !key.startsWith("x-")) {
                result.extra(location, key, node.get(key));
            }
        }

    } else {
        result.invalidType(location, "openapi", "object", node);
        result.invalid();
        return null;
    }

    return openAPI;
}

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public PathItem getPathItem(ObjectNode obj, String location, ParseResult result) {

    PathItem pathItem = new PathItem();

    if (obj.get("$ref") != null) {
        JsonNode ref = obj.get("$ref");

        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            String mungedRef = mungedRef(ref.textValue());
            if (mungedRef != null) {
                pathItem.set$ref(mungedRef);
            } else {
                pathItem.set$ref(ref.textValue());
            }//from  www  .  j a  va 2 s .  c o  m
            return pathItem;
        } else if (ref.getNodeType().equals(JsonNodeType.OBJECT)) {
            ObjectNode node = (ObjectNode) ref;

            // extra keys
            Set<String> keys = getKeys(node);
            for (String key : keys) {
                result.extra(location, key, node.get(key));
            }
        }
        return null;
    }

    String value = getString("summary", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        pathItem.setSummary(value);
    }

    value = getString("description", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        pathItem.setDescription(value);
    }

    ArrayNode parameters = getArray("parameters", obj, false, location, result);
    if (parameters != null && parameters.size() > 0) {
        pathItem.setParameters(getParameterList(parameters, location, result));
    }

    ArrayNode servers = getArray("servers", obj, false, location, result);
    if (servers != null && servers.size() > 0) {
        pathItem.setServers(getServersList(servers, location, result));
    }

    ObjectNode node = getObject("get", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(get)", result);
        if (operation != null) {
            pathItem.setGet(operation);
        }
    }
    node = getObject("put", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(put)", result);
        if (operation != null) {
            pathItem.setPut(operation);
        }
    }
    node = getObject("post", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(post)", result);
        if (operation != null) {
            pathItem.setPost(operation);
        }
    }
    node = getObject("head", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(head)", result);
        if (operation != null) {
            pathItem.setHead(operation);
        }
    }
    node = getObject("delete", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(delete)", result);
        if (operation != null) {
            pathItem.setDelete(operation);
        }
    }
    node = getObject("patch", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(patch)", result);
        if (operation != null) {
            pathItem.setPatch(operation);
        }
    }
    node = getObject("options", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(options)", result);
        if (operation != null) {
            pathItem.setOptions(operation);
        }
    }
    node = getObject("trace", obj, false, location, result);
    if (node != null) {
        Operation operation = getOperation(node, location + "(trace)", result);
        if (operation != null) {
            pathItem.setTrace(operation);
        }
    }

    Map<String, Object> extensions = getExtensions(obj);
    if (extensions != null && extensions.size() > 0) {
        pathItem.setExtensions(extensions);
    }

    Set<String> keys = getKeys(obj);
    for (String key : keys) {
        if (!PATHITEM_KEYS.contains(key) && !key.startsWith("x-")) {
            result.extra(location, key, obj.get(key));
        }
    }

    return pathItem;
}

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public List<SecurityRequirement> getSecurityRequirementsList(ArrayNode nodes, String location,
        ParseResult result) {//  w  w w. j a  va 2  s  .c  o m
    if (nodes == null)
        return null;

    List<SecurityRequirement> securityRequirements = new ArrayList<>();

    for (JsonNode node : nodes) {
        if (node.getNodeType().equals(JsonNodeType.OBJECT)) {
            SecurityRequirement securityRequirement = new SecurityRequirement();
            Set<String> keys = getKeys((ObjectNode) node);
            if (keys.size() == 0) {
                securityRequirements.add(securityRequirement);
            } else {
                for (String key : keys) {
                    if (key != null) {
                        JsonNode value = node.get(key);
                        if (key != null && JsonNodeType.ARRAY.equals(value.getNodeType())) {
                            ArrayNode arrayNode = (ArrayNode) value;
                            List<String> scopes = Stream.generate(arrayNode.elements()::next)
                                    .map((n) -> n.asText()).limit(arrayNode.size())
                                    .collect(Collectors.toList());
                            securityRequirement.addList(key, scopes);
                        }
                    }
                }
                if (securityRequirement.size() > 0) {
                    securityRequirements.add(securityRequirement);
                }
            }
        }
    }

    return securityRequirements;

}

From source file:org.activiti.editor.language.json.converter.BpmnJsonConverter.java

public void convertListenersToJson(List<EventListener> eventListeners, ObjectNode propertiesNode) {
    ObjectNode listenersNode = objectMapper.createObjectNode();
    ArrayNode itemsNode = objectMapper.createArrayNode();
    for (EventListener listener : eventListeners) {
        ObjectNode propertyItemNode = objectMapper.createObjectNode();

        propertyItemNode.put(PROPERTY_EVENT_LISTENER_EVENTS, listener.getEvents());
        propertyItemNode.put(PROPERTY_EVENT_LISTENER_ENTITY_TYPE, listener.getEntityType());

        if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_CLASS, listener.getImplementation());
        } else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION
                .equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_DELEGATEEXPRESSION, listener.getImplementation());
        } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT
                .equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_EVENT, PROPERTY_EVENT_LISTENER_THROW_SIGNAL);
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_REFERENCE, listener.getImplementation());
        } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT
                .equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_EVENT,
                    PROPERTY_EVENT_LISTENER_THROW_GLOBAL_SIGNAL);
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_REFERENCE, listener.getImplementation());
        } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT
                .equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_EVENT, PROPERTY_EVENT_LISTENER_THROW_MESSAGE);
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_REFERENCE, listener.getImplementation());
        } else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT
                .equals(listener.getImplementationType())) {
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_EVENT, PROPERTY_EVENT_LISTENER_THROW_ERROR);
            propertyItemNode.put(PROPERTY_EVENT_LISTENER_THROW_REFERENCE, listener.getImplementation());
        }//from ww  w.  j a  v a2 s.  c  om
        itemsNode.add(propertyItemNode);
    }

    listenersNode.put("totalCount", itemsNode.size());
    listenersNode.put(EDITOR_PROPERTIES_GENERAL_ITEMS, itemsNode);
    propertiesNode.put(PROPERTY_EVENT_LISTENERS, listenersNode);
}

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public Operation getOperation(ObjectNode obj, String location, ParseResult result) {
    if (obj == null) {
        return null;
    }/*from   w  w w  . j a  va  2 s. c o  m*/
    Operation operation = new Operation();

    ArrayNode array = getArray("tags", obj, false, location, result);
    List<String> tags = getTagsStrings(array, String.format("%s.%s", location, "tags"), result);
    if (tags != null) {
        operation.setTags(tags);
    }
    String value = getString("summary", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        operation.setSummary(value);
    }

    value = getString("description", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        operation.setDescription(value);
    }

    ObjectNode externalDocs = getObject("externalDocs", obj, false, location, result);
    ExternalDocumentation docs = getExternalDocs(externalDocs, String.format("%s.%s", location, "externalDocs"),
            result);
    if (docs != null) {
        operation.setExternalDocs(docs);
    }
    value = getString("operationId", obj, false, location, result, operationIDs);
    if (StringUtils.isNotBlank(value)) {
        operation.operationId(value);
    }

    ArrayNode parameters = getArray("parameters", obj, false, location, result);
    if (parameters != null) {
        operation.setParameters(
                getParameterList(parameters, String.format("%s.%s", location, "parameters"), result));
    }

    final ObjectNode requestObjectNode = getObject("requestBody", obj, false, location, result);
    if (requestObjectNode != null) {
        operation.setRequestBody(
                getRequestBody(requestObjectNode, String.format("%s.%s", location, "requestBody"), result));
    }

    ObjectNode responsesNode = getObject("responses", obj, true, location, result);
    ApiResponses responses = getResponses(responsesNode, String.format("%s.%s", location, "responses"), result);
    if (responses != null) {
        operation.setResponses(responses);
    }

    ObjectNode callbacksNode = getObject("callbacks", obj, false, location, result);
    Map<String, Callback> callbacks = getCallbacks(callbacksNode, String.format("%s.%s", location, "callbacks"),
            result);
    if (callbacks != null) {
        operation.setCallbacks(callbacks);
    }

    Boolean deprecated = getBoolean("deprecated", obj, false, location, result);
    if (deprecated != null) {
        operation.setDeprecated(deprecated);
    }

    array = getArray("servers", obj, false, location, result);
    if (array != null && array.size() > 0) {
        operation.setServers(getServersList(array, String.format("%s.%s", location, "servers"), result));
    }

    array = getArray("security", obj, false, location, result);
    if (array != null) {
        operation.setSecurity(
                getSecurityRequirementsList(array, String.format("%s.%s", location, "security"), result));
    }

    Map<String, Object> extensions = getExtensions(obj);
    if (extensions != null && extensions.size() > 0) {
        operation.setExtensions(extensions);
    }

    Set<String> keys = getKeys(obj);
    for (String key : keys) {
        if (!OPERATION_KEYS.contains(key) && !key.startsWith("x-")) {
            result.extra(location, key, obj.get(key));
        }
    }

    return operation;
}

From source file:org.walkmod.conf.providers.yml.AddTransformationYMLAction.java

@Override
public void doAction(JsonNode chainsNode) throws Exception {

    ArrayNode transformationsNode = null;

    boolean isMultiModule = chainsNode.has("modules");
    ObjectMapper mapper = provider.getObjectMapper();
    if (!isMultiModule) {
        boolean validChainName = chain != null && !"".equals(chain) && !"default".equals(chain);
        if (!chainsNode.has("chains")) {
            if (chainsNode.has("transformations")) {
                JsonNode aux = chainsNode.get("transformations");
                if (aux.isArray()) {
                    transformationsNode = (ArrayNode) aux;
                }// w ww  .  j av  a  2 s  . c  om

                if (!validChainName) {
                    ObjectNode auxRoot = (ObjectNode) chainsNode;
                    if (transformationsNode == null) {
                        transformationsNode = new ArrayNode(mapper.getNodeFactory());
                    }
                    auxRoot.set("transformations", transformationsNode);
                } else {
                    // reset the root
                    chainsNode = new ObjectNode(mapper.getNodeFactory());
                    ObjectNode auxRoot = (ObjectNode) chainsNode;

                    // the default chain list added
                    ObjectNode chainObject = new ObjectNode(mapper.getNodeFactory());
                    chainObject.set("name", new TextNode("default"));
                    chainObject.set("transformations", transformationsNode);
                    ArrayNode chainsListNode = new ArrayNode(mapper.getNodeFactory());

                    // the requested chain added
                    ObjectNode newChain = new ObjectNode(mapper.getNodeFactory());
                    newChain.set("name", new TextNode(chain));
                    if (path != null && !"".equals(path.trim())) {

                        ObjectNode readerNode = new ObjectNode(mapper.getNodeFactory());
                        newChain.set("reader", readerNode);

                        populateWriterReader(readerNode, path, null, null, null, null);

                        ObjectNode writerNode = new ObjectNode(mapper.getNodeFactory());
                        newChain.set("writer", writerNode);
                        populateWriterReader(writerNode, path, null, null, null, null);
                    }

                    transformationsNode = new ArrayNode(mapper.getNodeFactory());
                    newChain.set("transformations", transformationsNode);

                    if (before == null || !"default".equals(before)) {
                        chainsListNode.add(chainObject);
                    }
                    chainsListNode.add(newChain);
                    if (before != null && "default".equals(before)) {
                        chainsListNode.add(chainObject);
                    }
                    auxRoot.set("chains", chainsListNode);

                }
            } else {
                ObjectNode auxRoot = (ObjectNode) chainsNode;
                transformationsNode = new ArrayNode(mapper.getNodeFactory());
                boolean writeChainInfo = validChainName;
                if (!writeChainInfo) {
                    writeChainInfo = path != null && !"".equals(path.trim());
                    chain = "default";
                }
                if (writeChainInfo) {
                    ArrayNode auxChainsList = new ArrayNode(mapper.getNodeFactory());
                    ObjectNode aux = new ObjectNode(mapper.getNodeFactory());
                    auxChainsList.add(aux);
                    aux.set("name", new TextNode(chain));
                    if (path != null && !"".equals(path.trim())) {

                        ObjectNode readerNode = new ObjectNode(mapper.getNodeFactory());
                        aux.set("reader", readerNode);
                        populateWriterReader(readerNode, path, null, null, null, null);

                    }
                    auxRoot.set("chains", auxChainsList);
                    if (path != null && !"".equals(path.trim())) {

                        ObjectNode writerNode = new ObjectNode(mapper.getNodeFactory());
                        aux.set("writer", writerNode);
                        populateWriterReader(writerNode, path, null, null, null, null);
                    }

                    auxRoot = aux;
                }
                auxRoot.set("transformations", transformationsNode);
            }

        } else {
            if (validChainName) {
                JsonNode aux = chainsNode.get("chains");
                boolean found = false;
                if (aux.isArray()) {
                    Iterator<JsonNode> it = aux.elements();
                    while (it.hasNext()) {
                        JsonNode next = it.next();
                        if (next.has("name")) {
                            String id = next.get("name").asText();
                            if (chain.equals(id)) {
                                found = true;
                                if (next.has("transformations")) {
                                    JsonNode auxTrans = next.get("transformations");
                                    if (auxTrans.isArray()) {
                                        transformationsNode = (ArrayNode) auxTrans;
                                    } else {
                                        throw new Exception("The chain [" + chain
                                                + "] does not have a valid transformations node");
                                    }
                                } else if (next.isObject()) {
                                    ObjectNode auxNext = (ObjectNode) next;
                                    transformationsNode = new ArrayNode(mapper.getNodeFactory());
                                    auxNext.set("transformations", transformationsNode);
                                } else {
                                    throw new Exception(
                                            "The chain [" + chain + "] does not have a valid structure");
                                }
                            }
                        }

                    }
                    if (!found) {
                        ChainConfig chainCfg = new ChainConfigImpl();
                        chainCfg.setName(chain);
                        WalkerConfig walkerCfg = new WalkerConfigImpl();
                        List<TransformationConfig> transfs = new LinkedList<TransformationConfig>();
                        transfs.add(transformationCfg);
                        walkerCfg.setTransformations(transfs);
                        chainCfg.setWalkerConfig(walkerCfg);
                        provider.addChainConfig(chainCfg, false, before);
                        return;
                    }
                }
            } else {

                ObjectNode node = new ObjectNode(mapper.getNodeFactory());
                node.set("name", new TextNode(chain));
                ArrayNode transNodes = new ArrayNode(mapper.getNodeFactory());

                node.set("transformations", transNodes);
                ArrayNode array = (ArrayNode) chainsNode.get("chains");
                array.add(node);

                ObjectNode transformationNode = new ObjectNode(mapper.getNodeFactory());
                transNodes.add(transformationNode);

                createTransformation(transformationNode, transformationCfg);

                return;
            }
        }
        if (transformationsNode != null) {
            ObjectNode transformationNode = new ObjectNode(mapper.getNodeFactory());

            if (order != null && order < transformationsNode.size()) {
                transformationsNode.insert(order, transformationNode);
            } else {
                transformationsNode.add(transformationNode);
            }

            createTransformation(transformationNode, transformationCfg);
            provider.write(chainsNode);
            return;
        } else if (chain != null) {
            throw new Exception("The chain [" + chain + "] does not exists");
        }
    }

}