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

Introduction

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

Prototype

public ArrayNode add(JsonNode paramJsonNode)

Source Link

Usage

From source file:squash.booking.lambdas.core.BackupManager.java

@Override
public final ImmutablePair<List<Booking>, List<BookingRule>> backupAllBookingsAndBookingRules()
        throws Exception {

    if (!initialised) {
        throw new IllegalStateException("The backup manager has not been initialised");
    }/*from www.  j  av  a 2  s. co m*/

    // Encode bookings and booking rules as JSON
    JsonNodeFactory factory = new JsonNodeFactory(false);
    // Create a json factory to write the treenode as json.
    JsonFactory jsonFactory = new JsonFactory();
    ObjectNode rootNode = factory.objectNode();

    ArrayNode bookingsNode = rootNode.putArray("bookings");
    List<Booking> bookings = bookingManager.getAllBookings(false);
    for (Booking booking : bookings) {
        bookingsNode.add((JsonNode) (mapper.valueToTree(booking)));
    }

    ArrayNode bookingRulesNode = rootNode.putArray("bookingRules");
    List<BookingRule> bookingRules = ruleManager.getRules(false);
    for (BookingRule bookingRule : bookingRules) {
        bookingRulesNode.add((JsonNode) (mapper.valueToTree(bookingRule)));
    }

    // Add this, as will be needed for restore in most common case.
    rootNode.put("clearBeforeRestore", true);

    ByteArrayOutputStream backupDataStream = new ByteArrayOutputStream();
    PrintStream printStream = new PrintStream(backupDataStream);
    try (JsonGenerator generator = jsonFactory.createGenerator(printStream)) {
        mapper.writeTree(generator, rootNode);
    }
    String backupString = backupDataStream.toString(StandardCharsets.UTF_8.name());

    logger.log("Backing up all bookings and booking rules to S3 bucket");
    IS3TransferManager transferManager = getS3TransferManager();
    byte[] backupAsBytes = backupString.getBytes(StandardCharsets.UTF_8);
    ByteArrayInputStream backupAsStream = new ByteArrayInputStream(backupAsBytes);
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentLength(backupAsBytes.length);
    PutObjectRequest putObjectRequest = new PutObjectRequest(databaseBackupBucketName,
            "AllBookingsAndBookingRules", backupAsStream, metadata);
    TransferUtils.waitForS3Transfer(transferManager.upload(putObjectRequest), logger);
    logger.log("Backed up all bookings and booking rules to S3 bucket: " + backupString);

    // Backup to the SNS topic
    logger.log("Backing up all bookings and booking rules to SNS topic: " + adminSnsTopicArn);
    getSNSClient().publish(adminSnsTopicArn, backupString, "Sqawsh all-bookings and booking rules backup");

    return new ImmutablePair<>(bookings, bookingRules);
}

From source file:io.github.microcks.util.postman.PostmanTestStepsRunner.java

private ArrayNode buildQueryParams(List<Parameter> queryParameters) {
    ArrayNode jsonQPS = mapper.createArrayNode();
    for (Parameter parameter : queryParameters) {
        JsonNode jsonQP = mapper.createObjectNode();
        ((ObjectNode) jsonQP).put("key", parameter.getName());
        ((ObjectNode) jsonQP).put("value", parameter.getValue());
        jsonQPS.add(jsonQP);
    }/*  w ww .java 2 s  . c o m*/
    return jsonQPS;
}

From source file:managers.nodes.AVMManager.java

private Promise<List<JsonNode>> features(JsonNode properties) {
    Substructure avm = new Substructure(properties.get("uuid").asText());
    // 1. Get list of all features
    Promise<List<JsonNode>> nodes = Has.relationships.endNodes(avm);
    // 2. For each feature, collect targets
    Promise<List<JsonNode>> features = nodes.flatMap(new Function<List<JsonNode>, Promise<List<JsonNode>>>() {
        public Promise<List<JsonNode>> apply(List<JsonNode> nodes) {
            List<Promise<? extends JsonNode>> features = new ArrayList<Promise<? extends JsonNode>>();
            for (final JsonNode node : nodes) {
                ((ObjectNode) node).retain("name", "type");
                Promise<List<String>> targets = Feature.nodes.targets(node);
                Promise<JsonNode> feature = targets.map(new Function<List<String>, JsonNode>() {
                    public JsonNode apply(List<String> targets) {
                        ArrayNode targetNodes = JsonNodeFactory.instance.arrayNode();
                        for (String target : targets) {
                            targetNodes.add(target);
                        }//from www. j  a v  a 2 s . com
                        ((ObjectNode) node).put("targets", targetNodes);
                        return node;
                    }
                });
                features.add(feature);
            }
            return Promise.sequence(features);
        }
    });
    return features;
}

From source file:org.attribyte.api.pubsub.impl.server.BroadcastServlet.java

@Override
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException, ServletException {

    long startNanos = System.nanoTime();

    byte[] broadcastContent = ByteStreams.toByteArray(request.getInputStream());

    long endNanos = System.nanoTime();

    String topicURL = request.getPathInfo();

    if (maxBodyBytes > 0 && broadcastContent.length > maxBodyBytes) {
        logNotification(request, topicURL, NOTIFICATION_TOO_LARGE.statusCode, null);
        Bridge.sendServletResponse(NOTIFICATION_TOO_LARGE, response);
        return;/*from   ww w .java  2 s.  co  m*/
    }

    Response endpointResponse;
    if (topicURL != null) {
        if (filters.size() > 0) {
            String checkHeader = request.getHeader(BasicAuthScheme.AUTH_HEADER);
            for (BasicAuthFilter filter : filters) {
                if (filter.reject(topicURL, checkHeader)) {
                    logNotification(request, topicURL, Response.Code.UNAUTHORIZED, broadcastContent);
                    response.sendError(Response.Code.UNAUTHORIZED, "Unauthorized");
                    return;
                }
            }
        }

        try {

            Topic topic = topicCache != null ? topicCache.getIfPresent(topicURL) : null;
            if (topic == null) {
                topic = datastore.getTopic(topicURL, autocreateTopics);
                if (topicCache != null && topic != null) {
                    topicCache.put(topicURL, topic);
                }
            }

            if (topic != null) {
                NotificationMetrics globalMetrics = endpoint.getGlobalNotificationMetrics();
                NotificationMetrics metrics = endpoint.getNotificationMetrics(topic.getId());
                metrics.notificationSize.update(broadcastContent.length);
                globalMetrics.notificationSize.update(broadcastContent.length);
                long acceptTimeNanos = endNanos - startNanos;
                metrics.notifications.update(acceptTimeNanos, TimeUnit.NANOSECONDS);
                globalMetrics.notifications.update(acceptTimeNanos, TimeUnit.NANOSECONDS);
                Notification notification = new Notification(topic, null, broadcastContent); //No custom headers...

                final boolean queued = endpoint.enqueueNotification(notification);
                if (queued) {
                    if (replicationTopic != null) {
                        final boolean replicationQueued = endpoint
                                .enqueueNotification(new Notification(replicationTopic,
                                        Collections.singleton(
                                                new Header(REPLICATION_TOPIC_HEADER, topic.getURL())),
                                        broadcastContent));
                        if (!replicationQueued) { //What to do?
                            logger.error("Replication failure due to notification capacity limits!");
                        }
                    }
                    if (!jsonEnabled) {
                        endpointResponse = ACCEPTED_RESPONSE;
                    } else {
                        ResponseBuilder builder = new ResponseBuilder();
                        builder.setStatusCode(ACCEPTED_RESPONSE.statusCode);
                        builder.addHeader("Content-Type", ServerUtil.JSON_CONTENT_TYPE);
                        ObjectNode responseNode = JsonNodeFactory.instance.objectNode();
                        ArrayNode idsNode = responseNode.putArray("messageIds");
                        idsNode.add(Long.toString(notification.getCreateTimestampMicros()));
                        builder.setBody(responseNode.toString().getBytes(Charsets.UTF_8));
                        endpointResponse = builder.create();
                    }
                } else {
                    endpointResponse = CAPACITY_ERROR_RESPONSE;
                }
            } else {
                endpointResponse = UNKNOWN_TOPIC_RESPONSE;
            }
        } catch (DatastoreException de) {
            logger.error("Problem selecting topic", de);
            endpointResponse = INTERNAL_ERROR_RESPONSE;
        }
    } else {
        endpointResponse = NO_TOPIC_RESPONSE;
    }

    logNotification(request, topicURL, endpointResponse.statusCode, broadcastContent);
    Bridge.sendServletResponse(endpointResponse, response);
}

From source file:com.almende.eve.capabilities.Config.java

@Override
public JsonNode get(final String key) {
    JsonNode res = super.get(key);
    if ((res != null && !res.isObject()) || "extends".equals(key)) {
        return res;
    }//w  w  w .  j  av a  2  s  .c  o  m
    if (!configured && this.has("extends")) {
        setupExtend();
    }
    JsonNode otherres = null;
    Config result = null;
    for (Config other : getPointers()) {
        JsonNode val = other.get(key);
        if (val == null) {
            continue;
        }
        if (val.isArray()) {
            final ArrayNode array = JOM.createArrayNode();
            for (JsonNode elem : val) {
                final Config item = new Config();
                item.pointers.add(Config.decorate((ObjectNode) elem));
                array.add(item);
            }
            this.set(key, array);
            otherres = array;
        } else if (!val.isObject()) {
            otherres = val;
        } else {
            if (result == null) {
                result = Config.decorate((ObjectNode) res);
            }
            result.getPointers().add(Config.decorate((ObjectNode) val));
        }
    }
    if (otherres != null) {
        return otherres;
    }
    if (result != null) {
        return result;
    }
    return res;
}

From source file:org.apache.streams.rss.serializer.SyndEntrySerializer.java

private void serializeModules(ObjectNode root, JsonNodeFactory factory, List modules) {
    if (modules == null || modules.size() == 0)
        return;//from w  w w  . j  a  v a  2s .c o m
    ArrayNode modulesArray = factory.arrayNode();
    for (Object obj : modules) {
        if (obj instanceof Module) {
            Module mod = (Module) obj;
            if (mod.getUri() != null)
                modulesArray.add(mod.getUri());
        } else {
            LOGGER.debug(
                    "SyndEntry.getModules() items are not of type Module. Need to handle the case of class : {}",
                    obj.getClass().toString());
        }
    }
    root.put("modules", modulesArray);
}

From source file:org.onosproject.maven.OnosSwaggerMojo.java

private ObjectNode initializeRoot() {
    ObjectNode root = mapper.createObjectNode();
    root.put("swagger", "2.0");
    ObjectNode info = mapper.createObjectNode();
    root.set("info", info);

    root.put("basePath", webContext);
    info.put("version", apiVersion);
    info.put("title", apiTitle);
    info.put("description", apiDescription);

    ArrayNode produces = mapper.createArrayNode();
    produces.add("application/json");
    root.set("produces", produces);

    ArrayNode consumes = mapper.createArrayNode();
    consumes.add("application/json");
    root.set("consumes", consumes);

    return root;/* ww  w . j  a v  a2s.  c om*/
}

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

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

    ObjectMapper mapper = provider.getObjectMapper();

    if (node.has("conf-providers")) {
        JsonNode list = node.get("conf-providers");
        Iterator<JsonNode> it = list.iterator();
        boolean found = false;
        while (it.hasNext() && !found) {
            JsonNode next = it.next();/*from ww w.j  av a 2  s.  co  m*/
            found = providerCfg.getType().equals(next.get("type").asText());
        }
        if (!found) {
            if (list.isArray()) {
                ArrayNode aux = (ArrayNode) list;
                ObjectNode prov = new ObjectNode(mapper.getNodeFactory());
                prov.set("type", new TextNode(providerCfg.getType()));
                Map<String, Object> params = providerCfg.getParameters();
                if (params != null && !params.isEmpty()) {
                    populateParams(prov, params);
                }
                aux.add(prov);
                provider.write(node);
                return;
            }
        }
    } else {
        ArrayNode aux = new ArrayNode(mapper.getNodeFactory());
        ObjectNode prov = new ObjectNode(mapper.getNodeFactory());
        prov.set("type", new TextNode(providerCfg.getType()));
        Map<String, Object> params = providerCfg.getParameters();
        if (params != null && !params.isEmpty()) {
            populateParams(prov, params);
        }
        aux.add(prov);
        ObjectNode auxNode = (ObjectNode) node;
        auxNode.set("conf-providers", aux);
        provider.write(node);
        return;
    }

    return;

}

From source file:fr.gouv.vitam.query.parser.MdEsQueryParser.java

/**
 * $in : { name : [ value1, value2, ... ] }
 *
 * @param refCommand//from w w  w .  ja  v  a2s.co  m
 * @param command
 * @param tr0
 * @throws InvalidParseOperationException
 */
@Override
protected void analyzeIn(final String refCommand, final JsonNode command, final TypeRequest tr0,
        final REQUEST req) throws InvalidParseOperationException {
    if (command == null) {
        throw new InvalidParseOperationException("Not correctly parsed: " + refCommand);
    }
    final Entry<String, JsonNode> element = JsonHandler.checkUnicity(refCommand, command);
    inEs(tr0, req, element);
    tr0.requestModel = JsonHandler.createObjectNode();
    final ArrayNode objectMD = tr0.requestModel.putObject(element.getKey()).putArray(refCommand);
    for (final JsonNode value : element.getValue()) {
        objectMD.add(value);
    }
}

From source file:org.onlab.stc.Monitor.java

private void add(Step step, ArrayNode steps) {
    Box box = layout.get(step);//  w w w  .j  a v  a 2 s  .  com
    ObjectNode sn = mapper.createObjectNode().put("name", step.name()).put("isGroup", step instanceof Group)
            .put("status", status(coordinator.getStatus(step))).put("tier", box.tier())
            .put("depth", box.depth());
    if (step.group() != null) {
        sn.put("group", step.group().name());
    }
    steps.add(sn);
}