Rewrite client core logic, implement Guard API client

Author: RedGuys

build.gradle

@@ -5,7 +5,7 @@ plugins {
 apply plugin: 'maven'
 
 group 'ru.redguy'
-version '1.1.4'
+version '2.0.0'
 
 repositories {
     maven {
@@ -14,9 +14,9 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
-    implementation 'com.google.code.gson:gson:2.8.9'
-    implementation 'org.jetbrains:annotations:23.0.0'
+    implementation 'com.squareup.okhttp3:okhttp:5.3.2'
+    implementation 'com.google.code.gson:gson:2.13.2'
+    implementation 'org.jetbrains:annotations:26.1.0'
 }
 
 //utf-8

readme.md

@@ -5,7 +5,8 @@
 Library to use [redguy api](https://wiki.redguy.ru/Api "redguy api").
 
 ## Install
-gradle
+
+Gradle:
 ```groovy
 repositories {
     mavenCentral()
@@ -15,6 +16,45 @@ repositories {
 }
 
 dependencies {
-    compile group: 'ru.redguy', name: 'redguyapi', version: '1.1.0'
+    implementation group: 'ru.redguy', name: 'redguyapi', version: '2.0.0'
 }
 ```
+
+## Usage
+
+```java
+RedGuyApi api = RedGuyApi.builder("token")
+        .baseUrl("https://api.redguy.ru/")
+        .build();
+
+ServerInfo serverInfo = api.minecraft().serverInfo("play.example.org");
+User user = api.users().info();
+```
+
+For the default API URL, the short constructor is still available:
+
+```java
+RedGuyApi api = new RedGuyApi("token");
+```
+
+## Guard API
+
+Guard API uses a separate base URL and Bearer token authorization:
+
+```java
+GuardApi guard = GuardApi.builder("token").build();
+
+GasStatus gas = guard.gas().status(123456789L);
+AiPack pack = guard.ai().pack("Minecraft");
+UserInfoResponse user = guard.users().info(
+        "123456789",
+        Arrays.asList("-1001234567890")
+);
+```
+
+Public Guard endpoints can also be called without a token:
+
+```java
+GuardApi guard = GuardApi.builder().build();
+GasStatus gas = guard.gas().status(123456789L);
+```

src/main/java/ru/redguy/redguyapi/ApiError.java

@@ -1,33 +1,13 @@
 package ru.redguy.redguyapi;
 
-public class ApiError extends Exception {
-
-    private final int code;
-    private final String comment;
-
+public class ApiError extends RedGuyApiException {
     /**
      * The error returned by the api server, to clarify the reason, see https://wiki.redguy.ru/Api/Errors
      *
      * @param code    Error id
      * @param comment Error name
      */
     public ApiError(int code, String comment) {
-        super();
-        this.code = code;
-        this.comment = comment;
-    }
-
-    @Override
-    public String getMessage() {
-        return comment;
-    }
-
-    /**
-     * Returns error id, to clarify the reason, see https://wiki.redguy.ru/Api/Errors
-     *
-     * @return Error id
-     */
-    public int getCode() {
-        return code;
+        super(code, comment);
     }
 }

src/main/java/ru/redguy/redguyapi/RedGuyApi.java

@@ -1,50 +1,51 @@
 package ru.redguy.redguyapi;
 
-import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
+import com.google.gson.Gson;
+import okhttp3.OkHttpClient;
 import ru.redguy.redguyapi.hashes.Hashes;
 import ru.redguy.redguyapi.links.Links;
 import ru.redguy.redguyapi.minecraft.Minecraft;
-import ru.redguy.redguyapi.news.News;
 import ru.redguy.redguyapi.text.Text;
 import ru.redguy.redguyapi.token.Token;
 import ru.redguy.redguyapi.users.Users;
 
-import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 public class RedGuyApi {
-
-    private final Map<String, String> options;
-
-    private RedGuyApi() {
-        this.options = new HashMap<>();
-    }
+    private final RedGuyApiClient client;
 
     /**
      * Constructs main api object.
      *
      * @param token Your api token.
      */
     public RedGuyApi(String token) {
-        this.options = verifyOptions(new HashMap<>(), token);
+        this(RedGuyApiConfig.configBuilder(token).build());
     }
 
     /**
      * Constructs main api object with specified params.
      *
      * @param token   Your api token.
      * @param options Additional client params
+     * @deprecated use {@link #builder(String)}.
      */
+    @Deprecated
     public RedGuyApi(String token, Map<String, String> options) {
-        this.options = verifyOptions(options, token);
+        RedGuyApiConfig.Builder builder = RedGuyApiConfig.configBuilder(token);
+        if (options.containsKey("baseUrl")) {
+            builder.baseUrl(options.get("baseUrl"));
+        }
+        this.client = new RedGuyApiClient(builder.build());
+    }
+
+    public RedGuyApi(RedGuyApiConfig config) {
+        this.client = new RedGuyApiClient(Objects.requireNonNull(config, "config"));
     }
 
-    @NotNull
-    @Contract("_, _ -> param1")
-    private Map<String, String> verifyOptions(@NotNull Map<String, String> options, String token) {
-        options.put("token", token);
-        return options;
+    public static Builder builder(String token) {
+        return new Builder(token);
     }
 
     /**
@@ -53,7 +54,7 @@ private Map<String, String> verifyOptions(@NotNull Map<String, String> options,
      * @return Minecraft API section
      */
     public Minecraft minecraft() {
-        return new Minecraft(options);
+        return new Minecraft(client);
     }
 
     /**
@@ -62,7 +63,7 @@ public Minecraft minecraft() {
      * @return Token API section
      */
     public Token token() {
-        return new Token(options);
+        return new Token(client);
     }
 
     /**
@@ -71,16 +72,7 @@ public Token token() {
      * @return Users API section
      */
     public Users users() {
-        return new Users(options);
-    }
-
-    /**
-     * Returns new instance of News API section
-     *
-     * @return News API section
-     */
-    public News news() {
-        return new News(options);
+        return new Users(client);
     }
 
     /**
@@ -89,7 +81,7 @@ public News news() {
      * @return Hashes API section
      */
     public Hashes hashes() {
-        return new Hashes(options);
+        return new Hashes(client);
     }
 
     /**
@@ -98,10 +90,41 @@ public Hashes hashes() {
      * @return Links API section
      */
     public Links links() {
-        return new Links(options);
+        return new Links(client);
     }
 
     public Text text() {
-        return new Text(options);
+        return new Text(client);
+    }
+
+    public static final class Builder {
+        private final RedGuyApiConfig.Builder configBuilder;
+
+        private Builder(String token) {
+            this.configBuilder = RedGuyApiConfig.configBuilder(token);
+        }
+
+        public Builder baseUrl(String baseUrl) {
+            configBuilder.baseUrl(baseUrl);
+            return this;
+        }
+
+        public Builder httpClient(OkHttpClient httpClient) {
+            configBuilder.httpClient(httpClient);
+            return this;
+        }
+
+        public Builder gson(Gson gson) {
+            configBuilder.gson(gson);
+            return this;
+        }
+
+        public RedGuyApiConfig config() {
+            return configBuilder.build();
+        }
+
+        public RedGuyApi build() {
+            return new RedGuyApi(config());
+        }
     }
 }

src/main/java/ru/redguy/redguyapi/RedGuyApiClient.java

@@ -0,0 +1,97 @@
+package ru.redguy.redguyapi;
+
+import com.google.gson.JsonElement;
+import okhttp3.HttpUrl;
+import okhttp3.MediaType;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import org.jetbrains.annotations.NotNull;
+import ru.redguy.redguyapi.internal.ApiEnvelope;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
+public final class RedGuyApiClient {
+    private static final MediaType JSON_MEDIA_TYPE = MediaType.get("application/json; charset=utf-8");
+
+    private final RedGuyApiConfig config;
+
+    public RedGuyApiClient(@NotNull RedGuyApiConfig config) {
+        this.config = config;
+    }
+
+    public <T> T get(String path, Class<T> responseType) throws ApiError, IOException {
+        return get(path, Collections.emptyMap(), responseType);
+    }
+
+    public <T> T get(String path, Map<String, ?> query, Class<T> responseType) throws ApiError, IOException {
+        Request request = new Request.Builder()
+                .url(url(path, query))
+                .get()
+                .build();
+        return execute(request, responseType);
+    }
+
+    public void get(String path, Map<String, ?> query) throws ApiError, IOException {
+        get(path, query, Void.class);
+    }
+
+    public <T> T post(String path, Object body, Class<T> responseType) throws ApiError, IOException {
+        return post(path, Collections.emptyMap(), body, responseType);
+    }
+
+    public <T> T post(String path, Map<String, ?> query, Object body, Class<T> responseType) throws ApiError, IOException {
+        String jsonBody = body instanceof String ? (String) body : config.getGson().toJson(body);
+        Request request = new Request.Builder()
+                .url(url(path, query))
+                .post(RequestBody.create(jsonBody, JSON_MEDIA_TYPE))
+                .build();
+        return execute(request, responseType);
+    }
+
+    private <T> T execute(Request request, Class<T> responseType) throws ApiError, IOException {
+        try (Response response = config.getHttpClient().newCall(request).execute()) {
+            ResponseBody body = response.body();
+            String responseBody = body == null ? "" : body.string();
+            ApiEnvelope result = config.getGson().fromJson(responseBody, ApiEnvelope.class);
+            if (result == null) {
+                throw new IOException("Empty API response");
+            }
+            if (!result.isSuccessful()) {
+                throw new ApiError(result.getCode(), result.getComment());
+            }
+            if (responseType == null || responseType == Void.class) {
+                return null;
+            }
+            JsonElement responseElement = result.getResponse();
+            return config.getGson().fromJson(responseElement, responseType);
+        }
+    }
+
+    private HttpUrl url(String path, Map<String, ?> query) {
+        HttpUrl.Builder builder = config.getBaseUrl().newBuilder()
+                .addPathSegments(trimSlashes(path));
+        builder.addQueryParameter("token", config.getToken());
+        query.forEach((name, value) -> {
+            if (value != null) {
+                builder.addQueryParameter(name, String.valueOf(value));
+            }
+        });
+        return Objects.requireNonNull(builder.build(), "url");
+    }
+
+    private static String trimSlashes(String path) {
+        String result = path;
+        while (result.startsWith("/")) {
+            result = result.substring(1);
+        }
+        while (result.endsWith("/")) {
+            result = result.substring(0, result.length() - 1);
+        }
+        return result;
+    }
+}