io.micronaut.http.annotation.Get Java Examples

@Get // <1>
public List<FlashBriefingItem> index() {
    return flashBriefingRepository.find()
            .stream()
            .filter(item -> validator.validate(item).isEmpty()) // <2>
            .sorted() // <3>
            .limit(5) // <4>
            .collect(Collectors.toList());
}
 

@Get("/{id}/queue")
public Single<HttpResponse> queue(@RequestAttribute("session") Session session, long id) {
    if (!session.hasGuild(id)) {
        return Single.just(ErrorResponse.get(ErrorCode.UNKNOWN_GUILD));
    }

    return channel.send(new JsonObject().put("cmd", "queue").put("guild", id))
            .singleOrError()
            .timeout(10, TimeUnit.SECONDS)
            .flatMap(reply -> Single.<HttpResponse>just(HttpResponse.ok(reply.encode())))
            .onErrorResumeNext(err -> Single.just(HttpResponse.ok("{\"queue\":[],\"repeating\":false}")));
}
 

@Get("/guilds")
public Single<String> guilds() {
    return guildCounts.valueIterator()
            .reduce(Integer::sum)
            .map(count -> new JsonObject()
                    .put("count", count)
                    .encode()).toSingle();
}
 

@Get("/oauth2exchange")
Single<HttpResponse> oauth2exchange(@Nullable String code, @Nullable Boolean bot) {
    var scope = "identify guilds" + (bot != null && bot ? " bot" : "");
    return sessionManager.exchangeCode(code, Settings.instance().apiUrls().get("redirect"), scope)
            .switchIfEmpty(Maybe.error(new NoSuchElementException("no element returned")))
            .doOnError(err -> logger.error("Error while exchanging OAuth2 code!", err))
            .flatMapSingle(session -> Single.<HttpResponse>just(HttpResponse.ok(new OAuth2ExchangeResponse(session.getToken()))))
            .onErrorReturnItem(ErrorResponse.get(ErrorCode.INVALID_OAUTH2_CODE));
}
 

@Get("/guilds/{id}")
Single<HttpResponse> guild(@RequestAttribute("session") Session session, long id) {
    if (!session.hasGuild(id)) {
        return Single.just(ErrorResponse.get(ErrorCode.UNKNOWN_GUILD));
    }

    return Flowable.fromFuture(Main.getCatnip().rest().guild()
            .getGuild(String.valueOf(id))
            .thenApply(KGuildExt::new)
            .toCompletableFuture())
            .singleOrError()
            .flatMap(guild -> Single.<MutableHttpResponse<?>>just(HttpResponse.ok(guild))
                    .onErrorReturn(err -> ErrorResponse.get(ErrorCode.UNKNOWN_GUILD)));
}
 

/**
 * Handles GraphQL {@code GET} requests.
 *
 * @param query         the GraphQL query
 * @param operationName the GraphQL operation name
 * @param variables     the GraphQL variables
 * @param httpRequest   the HTTP request
 * @return the GraphQL response
 */
@Get(produces = APPLICATION_JSON, single = true)
public Publisher<String> get(
        @QueryValue("query") String query,
        @Nullable @QueryValue("operationName") String operationName,
        @Nullable @QueryValue("variables") String variables,
        HttpRequest httpRequest) {

    // https://graphql.org/learn/serving-over-http/#get-request
    //
    // When receiving an HTTP GET request, the GraphQL query should be specified in the "query" query string.
    // For example, if we wanted to execute the following GraphQL query:
    //
    // {
    //   me {
    //     name
    //   }
    // }
    //
    // This request could be sent via an HTTP GET like so:
    //
    // http://myapi/graphql?query={me{name}}
    //
    // Query variables can be sent as a JSON-encoded string in an additional query parameter called "variables".
    // If the query contains several named operations,
    // an "operationName" query parameter can be used to control which one should be executed.

    return executeRequest(query, operationName, convertVariablesJson(variables), httpRequest);
}
 

@Get("/multi-cookie")
HttpResponse<String> multiCookie() {
    final MutableHttpResponse<String> response = HttpResponse.ok(BODY_TEXT_RESPONSE);
    response.cookie(Cookie.of(COOKIE_NAME, COOKIE_VALUE).domain(COOKIE_DOMAIN).path(COOKIE_PATH))
            .cookie(Cookie.of(COOKIE_NAME + "2", COOKIE_VALUE + "2").domain(COOKIE_DOMAIN).path(COOKIE_PATH));
    return response;
}
 

@Get(value = "/fortunes", produces = "text/html;charset=utf-8")
public Single<ModelAndView<Map>> fortune() {
    return dbRepository.fortunes().toList().flatMap(fortunes -> {
        fortunes.add(new Fortune(0, "Additional fortune added at request time."));
        fortunes.sort(comparing(fortune -> fortune.message));
        return Single.just(new ModelAndView<>("fortunes", Collections.singletonMap("fortunes", fortunes)));
    });
}
 

@Get("/updates")
public Single<List<World>> updates(@QueryValue String queries) {
    Flowable<World>[] worlds = new Flowable[parseQueryCount(queries)];

    Arrays.setAll(worlds, i ->
            dbRepository.findAndUpdateWorld(randomWorldNumber(), randomWorldNumber()).toFlowable()
    );

    return Flowable.merge(Arrays.asList(worlds)).toList();
}
 

@Get("/{name}")
FeaturesEndpoint.Feature features(String name);
 

@Get("/{name}")
String greet(String name);
 

@Get("/")
Single<Map> getJson() {
    Map<String, String> map = new HashMap<>();
    map.put("message", "Hello, World!");
    return Single.just(map);
}
 

@Get("/{name}")
public String greet(String name) {
    return greetingService.getGreeting() + name;
}
 

@Get("/{name}")
public Single<String> greet(String name) {
    return Single.just(greetingService.getGreeting() + name);
}
 

@Get("/")
@Produces(MediaType.TEXT_PLAIN)
public String index() {
  return "Hello World!";
}
 

@Get(value = "/", produces = MediaType.TEXT_PLAIN)
Single<String> getPlainText() {
    return Single.just(TEXT);
}
 

@Get("/db")
public Single<World> db() {
    return dbRepository.getWorld(randomWorldNumber());
}
 

@Get("/{name}")
Optional<Pet> byName(String name) {
    return petRepository.findByName(name);
}
 

@Get("/shards")
public Single<List<ShardStatus>> shards() {
    return shardStatus.valueIterator().toList();
}
 

@Get("/info")
User me(@RequestAttribute("session") Session session) {
    return session.user();
}
 

@Get("/{policyNumber}")
GetPolicyDetailsQueryResult get(String policyNumber) {
    return policyClient.get(policyNumber);
}
 

@Get("/")
Map<String, FeaturesEndpoint.Feature> features();
 

@Get("/")
String hello();
 

@Override
protected AnnotationValueBuilder<?> newBuilder(HttpMethod httpMethod, AnnotationValue<Annotation> annotation) {
    return AnnotationValue.builder(Get.class);
}
 

@Get("/{productCode}")
public Maybe<ProductDto> get(String productCode) {
    return client.get(productCode);
}
 

@Get
public Single<List<ProductDto>> getAll() {
    return client.getAll();
}
 

@Get("/accounts")
Collection<PolicyAccountDto> accounts() {
    return paymentClient.accounts();
}
 

@Get("/{policyNumber}")
FindDocumentsResult find(String policyNumber) {
    return client.find(policyNumber);
}
 

@Override
@Get("/policies/{policyNumber}")
GetPolicyDetailsQueryResult get(String policyNumber);
 

@Get("/{policyNumber}")
GetPolicyDetailsQueryResult get(@NotNull String policyNumber);