Java Code Examples for elemental.json.JsonObject#get()

@Override
public Optional<Runnable> handle(UI ui, JsonObject invocationJson) {
    History history = ui.getPage().getHistory();

    HistoryStateChangeHandler historyStateChangeHandler = history
            .getHistoryStateChangeHandler();
    if (historyStateChangeHandler != null) {
        JsonValue state = invocationJson
                .get(JsonConstants.RPC_NAVIGATION_STATE);
        String location = invocationJson
                .getString(JsonConstants.RPC_NAVIGATION_LOCATION);

        boolean triggeredByLink = invocationJson
                .hasKey(JsonConstants.RPC_NAVIGATION_ROUTERLINK);
        NavigationTrigger trigger = triggeredByLink
                ? NavigationTrigger.ROUTER_LINK
                : NavigationTrigger.HISTORY;

        HistoryStateChangeEvent event = new HistoryStateChangeEvent(history,
                state, new Location(location), trigger);
        historyStateChangeHandler.onHistoryStateChange(event);
    }

    return Optional.empty();
}
 

/**
 * Makes an UIDL request to the server.
 *
 * @param reqInvocations
 *            Data containing RPC invocations and all related information.
 * @param extraJson
 *            Parameters that are added to the payload
 */
protected void send(final JsonArray reqInvocations,
        final JsonObject extraJson) {
    registry.getRequestResponseTracker().startRequest();

    JsonObject payload = Json.createObject();
    String csrfToken = registry.getMessageHandler().getCsrfToken();
    if (!csrfToken.equals(ApplicationConstants.CSRF_TOKEN_DEFAULT_VALUE)) {
        payload.put(ApplicationConstants.CSRF_TOKEN, csrfToken);
    }
    payload.put(ApplicationConstants.RPC_INVOCATIONS, reqInvocations);
    payload.put(ApplicationConstants.SERVER_SYNC_ID,
            registry.getMessageHandler().getLastSeenServerSyncId());
    payload.put(ApplicationConstants.CLIENT_TO_SERVER_ID,
            clientToServerMessageId++);

    if (extraJson != null) {
        for (String key : extraJson.keys()) {
            JsonValue value = extraJson.get(key);
            payload.put(key, value);
        }
    }

    send(payload);

}
 

private static <T extends JsonValue> T computeIfAbsent(
        JsonObject jsonObject, String key, Supplier<T> valueSupplier) {
    T result = jsonObject.get(key);
    if (result == null) {
        result = valueSupplier.get();
        jsonObject.put(key, result);
    }
    return result;
}
 

int addDependency(JsonObject json, String key, String pkg, String version) {
    Objects.requireNonNull(json, "Json object need to be given");
    Objects.requireNonNull(key, "Json sub object needs to be give.");
    Objects.requireNonNull(pkg, "dependency package needs to be defined");

    JsonObject vaadinDeps = json.getObject(VAADIN_DEP_KEY);
    if (!json.hasKey(key)) {
        json.put(key, Json.createObject());
    }
    json = json.get(key);
    vaadinDeps = vaadinDeps.getObject(key);

    if (vaadinDeps.hasKey(pkg)) {
        if (version == null) {
            version = vaadinDeps.getString(pkg);
        }
        return handleExistingVaadinDep(json, pkg, version, vaadinDeps);
    } else {
        vaadinDeps.put(pkg, version);
        if (!json.hasKey(pkg) || new FrontendVersion(version)
                .isNewerThan(toVersion(json, pkg))) {
            json.put(pkg, version);
            log().debug("Added \"{}\": \"{}\" line.", pkg, version);
            return 1;
        }
    }
    return 0;
}
 

private void collectDependencies(JsonObject obj) {
    for (String key : obj.keys()) {
        JsonValue value = obj.get(key);
        if (!(value instanceof JsonObject)) {
            continue;
        }
        JsonObject json = (JsonObject) value;
        if (json.hasKey(NPM_NAME)) {
            addDependency(json);
        } else {
            collectDependencies(json);
        }
    }
}
 

private String getShrinkWrapVersion(JsonObject packageJson) {
    if (packageJson == null) {
        return null;
    }
    if (packageJson.hasKey(DEPENDENCIES)) {
        JsonObject dependencies = packageJson.getObject(DEPENDENCIES);
        if (dependencies.hasKey(SHRINK_WRAP)) {
            JsonValue value = dependencies.get(SHRINK_WRAP);
            return value.asString();
        }
    }
    return null;
}
 

private static DebouncePhase extractPhase(JsonObject eventData) {
    JsonValue jsonValue = eventData.get(JsonConstants.EVENT_DATA_PHASE);
    if (jsonValue == null) {
        return DebouncePhase.LEADING;
    } else {
        return DebouncePhase.forIdentifier(jsonValue.asString());
    }
}
 

private void handleExtendedClientDetailsResponse(JsonValue json) {
    if (!(json instanceof JsonObject)) {
        throw new RuntimeException("Expected a JSON object");
    }
    final JsonObject jsonObj = (JsonObject) json;

    // Note that JSON returned is a plain string -> string map, the actual
    // parsing of the fields happens in ExtendedClient's constructor. If a
    // field is missing or the wrong type, pass on null for default.
    final Function<String, String> getStringElseNull = key -> {
        final JsonValue jsValue = jsonObj.get(key);
        if (jsValue != null && JsonType.STRING.equals(jsValue.getType())) {
            return jsValue.asString();
        } else {
            return null;
        }
    };
    ui.getInternals()
            .setExtendedClientDetails(new ExtendedClientDetails(
                    getStringElseNull.apply("v-sw"),
                    getStringElseNull.apply("v-sh"),
                    getStringElseNull.apply("v-ww"),
                    getStringElseNull.apply("v-wh"),
                    getStringElseNull.apply("v-bw"),
                    getStringElseNull.apply("v-bh"),
                    getStringElseNull.apply("v-tzo"),
                    getStringElseNull.apply("v-rtzo"),
                    getStringElseNull.apply("v-dstd"),
                    getStringElseNull.apply("v-dston"),
                    getStringElseNull.apply("v-tzid"),
                    getStringElseNull.apply("v-curdate"),
                    getStringElseNull.apply("v-td"),
                    getStringElseNull.apply("v-pr"),
                    getStringElseNull.apply("v-wn"),
                    getStringElseNull.apply("v-np")));
}
 

@Test
public void npmIsInUse_packageJsonContainsFlowDeps_removeFlowDeps()
        throws IOException {
    // Generate package json in a proper format first
    packageCreator.execute();
    packageUpdater.execute();

    JsonObject packJsonObject = getPackageJson(packageJson);
    JsonObject deps = packJsonObject.get(DEPENDENCIES);

    packageUpdater.execute();

    assertPackageJsonFlowDeps();
}
 

private void assertPackageJsonFlowDeps() throws IOException {
    JsonObject packJsonObject = getPackageJson(packageJson);
    JsonObject deps = packJsonObject.get(DEPENDENCIES);
    // No Flow deps
    Assert.assertFalse(deps.hasKey(DEP_NAME_FLOW_DEPS));
    // No old package hash
    Assert.assertFalse(deps.hasKey(VAADIN_APP_PACKAGE_HASH));
    // Contains initially generated default polymer dep
    Assert.assertTrue(deps.hasKey("@polymer/polymer"));
    // Contains new hash
    Assert.assertTrue(
            packJsonObject.getObject("vaadin")
                    .hasKey("hash"));
}
 

private JreJsonArray extractParametersData(Method method) {
    ConstantPoolKey parametersData = (ConstantPoolKey) stateNode
            .getFeature(PolymerEventListenerMap.class)
            .get(method.getName());
    assertNotNull(parametersData);

    JsonObject json = Json.createObject();
    parametersData.export(json);
    return json.get(parametersData.getId());
}
 

@Test
public void testNodeValueType() {
    StateNode value = StateNodeTest.createEmptyNode("value");
    MapPutChange change = new MapPutChange(feature, "myKey", value);

    JsonObject json = change.toJson(null);
    Assert.assertFalse(json.hasKey(JsonConstants.CHANGE_PUT_VALUE));

    JsonValue nodeValue = json.get(JsonConstants.CHANGE_PUT_NODE_VALUE);
    Assert.assertSame(JsonType.NUMBER, nodeValue.getType());
    Assert.assertEquals(value.getId(), (int) nodeValue.asNumber());
}
 

private void collectDeps(JsonObject target, JsonObject dep) {
    if (!dep.hasKey(DEPENDENCIES)) {
        return;
    }
    JsonObject deps = dep.get(DEPENDENCIES);
    for (String key : deps.keys()) {
        JsonValue value = deps.get(key);
        if (value instanceof JsonObject) {
            addDependency(target, key, (JsonObject) value);
            collectDeps(target, (JsonObject) value);
        }
    }
}
 

private static boolean resolveFilters(Node element, String eventType,
        JsonObject expressionSettings, JsonObject eventData,
        Consumer<String> sendCommand) {

    boolean noFilters = true;
    boolean atLeastOneFilterMatched = false;

    for (String expression : expressionSettings.keys()) {
        JsonValue settings = expressionSettings.get(expression);

        boolean hasDebounce = settings.getType() == JsonType.ARRAY;

        if (!hasDebounce && !settings.asBoolean()) {
            continue;
        }
        noFilters = false;

        boolean filterMatched = eventData != null
                && eventData.getBoolean(expression);
        if (hasDebounce && filterMatched) {
            String debouncerId = "on-" + eventType + ":" + expression;

            // Count as a match only if at least one debounce is eager
            filterMatched = resolveDebounces(element, debouncerId,
                    (JsonArray) settings, sendCommand);
        }

        atLeastOneFilterMatched |= filterMatched;
    }

    return noFilters || atLeastOneFilterMatched;
}
 

private String getPolymerVersion(JsonObject object) {
    JsonObject deps = object.get("dependencies");
    String version = deps.getString("@polymer/polymer");
    return version;
}
 

private JsonValue getValue(Object input) {
    MapPutChange change = new MapPutChange(feature, "myKey", input);
    JsonObject json = change.toJson(null);
    return json.get(JsonConstants.CHANGE_PUT_VALUE);
}