Player Password File for "account database"

build.gradle

@@ -89,6 +89,13 @@ spotless {
             include 'src/**/*.java'
             exclude '**/JTextAreaAppender.java'
             exclude '**/TransferableHelper.java' // Temporary until switch expression is supported.
+            exclude '**/MapToolInfo.java' // Temporary until supported.
+            exclude '**/PlayerDatabaseInfo.java' // Temporary until supported.
+            exclude '**/PlayerInfo.java' // Temporary until supported.
+            exclude '**/PlayTimeInfo.java' // Temporary until supported.
+            exclude '**/NoData.java' // Temporary until supported.
+            exclude '**/PlayTime.java' // Temporary until supported.
+            exclude '**/CipherUtil.java' // Temporary until supported.
         }
         licenseHeaderFile 'spotless.license.java'
 
@@ -395,6 +402,10 @@ dependencies {
     // Noise Generator
     implementation 'com.github.cwisniew:NoiseLib:1.0.0' // The most recent version, 1.0.0 is build for a later java version: major version 55 is newer than 54, the highest major version supported by this compiler
 
+
+
+    // HTTP End Point
+    implementation 'javax.ws.rs:javax.ws.rs-api:2.1.1'
 }
 
 

src/main/java/net/rptools/clientserver/simple/server/ServerConnection.java

@@ -105,7 +105,7 @@ public void sendMessage(String id, Object channel, byte[] message) {
    * Server subclasses may override this method to perform serial handshaking before the connection
    * is accepted into its pool. By default, this just returns true.
    *
-   * @param conn
+   * @param id
    * @return true if the connection should be added to the pool
    */
   public boolean handleConnectionHandshake(String id, Socket socket) {

src/main/java/net/rptools/maptool/api/ApiData.java

@@ -0,0 +1,26 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.maptool.api;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+
+public interface ApiData {
+
+  default JsonObject asJsonObject() {
+    Gson gson = new Gson();
+    return gson.toJsonTree(this).getAsJsonObject();
+  }
+}

src/main/java/net/rptools/maptool/api/ApiException.java

@@ -0,0 +1,26 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.maptool.api;
+
+public class ApiException extends Exception {
+
+  public ApiException(String message) {
+    super(message);
+  }
+
+  public ApiException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

src/main/java/net/rptools/maptool/api/maptool/MapToolApi.java

@@ -0,0 +1,25 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.maptool.api.maptool;
+
+import java.util.concurrent.CompletableFuture;
+import net.rptools.maptool.api.util.ApiResult;
+
+public class MapToolApi {
+
+  public CompletableFuture<ApiResult<MapToolInfo>> getVersion() {
+    return CompletableFuture.completedFuture(new ApiResult<MapToolInfo>(new MapToolInfo()));
+  }
+}

src/main/java/net/rptools/maptool/api/maptool/MapToolInfo.java

@@ -0,0 +1,16 @@
+package net.rptools.maptool.api.maptool;
+
+import net.rptools.maptool.api.ApiData;
+import net.rptools.maptool.client.MapTool;
+
+//@XmlRootElement
+public record MapToolInfo(
+    String mapToolVersion,
+    String webEndpointVersion,
+    boolean developmentVersion
+) implements ApiData {
+
+  public MapToolInfo() {
+    this(MapTool.getVersion(), "unavailable", MapTool.isDevelopment());
+  }
+}

src/main/java/net/rptools/maptool/api/player/PlayTimeInfo.java

@@ -0,0 +1,27 @@
+package net.rptools.maptool.api.player;
+
+import com.google.gson.JsonObject;
+import java.time.DayOfWeek;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
+import net.rptools.maptool.api.ApiData;
+import net.rptools.maptool.model.player.PlayTime;
+
+public record PlayTimeInfo(
+    DayOfWeek dayOfWeek,
+    LocalTime startTime,
+    LocalTime endTime
+) implements ApiData {
+  public PlayTimeInfo(PlayTime playTime) {
+    this(playTime.dayOfWeek(), playTime.startTime(), playTime.endTime());
+  }
+
+  @Override
+  public JsonObject asJsonObject() {
+    JsonObject json = new JsonObject();
+    json.addProperty("dayOfWeek", dayOfWeek.getValue());
+    json.addProperty("startTime", startTime.format(DateTimeFormatter.ISO_LOCAL_TIME));
+    json.addProperty("endTime", startTime.format(DateTimeFormatter.ISO_LOCAL_TIME));
+    return json;
+  }
+}

src/main/java/net/rptools/maptool/api/player/PlayerApi.java

@@ -0,0 +1,157 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.maptool.api.player;
+
+import java.lang.reflect.InvocationTargetException;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import net.rptools.maptool.api.ApiException;
+import net.rptools.maptool.api.util.ApiCall;
+import net.rptools.maptool.api.util.ApiListResult;
+import net.rptools.maptool.api.util.ApiResult;
+import net.rptools.maptool.client.MapTool;
+import net.rptools.maptool.model.player.Player;
+import net.rptools.maptool.model.player.Player.Role;
+import net.rptools.maptool.model.player.PlayerDatabase;
+import net.rptools.maptool.model.player.PlayerDatabaseFactory;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class PlayerApi {
+
+  private static final Logger log = LogManager.getLogger(PlayerApi.class);
+
+  public CompletableFuture<ApiResult<PlayerInfo>> getPlayer(String name) {
+    return new ApiCall<PlayerInfo>().runOnSwingThread(() -> getPlayerInfo(name));
+  }
+
+  public CompletableFuture<ApiResult<PlayerInfo>> getPlayer() {
+    return new ApiCall<PlayerInfo>()
+        .runOnSwingThread(
+            () -> {
+              Player player = MapTool.getPlayer();
+              return getPlayerInfo(player.getName());
+            });
+  }
+
+  public CompletableFuture<ApiListResult<PlayerInfo>> getConnectedPlayers() {
+    return CompletableFuture.supplyAsync(
+        () -> {
+          try {
+            return new ApiListResult<>(
+                getPlayersInfo().stream()
+                    .filter(PlayerInfo::connected)
+                    .collect(Collectors.toList()));
+          } catch (InterruptedException
+              | InvocationTargetException
+              | NoSuchAlgorithmException
+              | InvalidKeySpecException e) {
+            log.error(e);
+            return new ApiListResult<>(new ApiException("err.internal", e));
+          }
+        });
+  }
+
+  public CompletableFuture<ApiListResult<PlayerInfo>> getDatabasePlayers() {
+    return CompletableFuture.supplyAsync(
+        () -> {
+          try {
+            return new ApiListResult<>(getPlayersInfo());
+          } catch (InterruptedException
+              | InvocationTargetException
+              | NoSuchAlgorithmException
+              | InvalidKeySpecException e) {
+            log.error(e);
+            return new ApiListResult<>(new ApiException("err.internal", e));
+          }
+        });
+  }
+
+  public CompletableFuture<ApiResult<PlayerDatabaseInfo>> getDatabaseCapabilities() {
+    return CompletableFuture.supplyAsync(() -> new ApiResult<>(getPlayerDatabaseInfo()));
+  }
+
+  /*
+  public CompletableFuture<ApiResult<NoData>> disablePlayer(String playerName, String reason) {
+    return CompletableFuture.supplyAsync(() -> {
+      PlayerDatabase playerDatabase = PlayerDatabaseFactory.getCurrentPlayerDatabase();
+      try {
+        Player player = playerDatabase.getPlayer(playerName);
+        if (player == null) {
+          return CompletableFuture.completedFuture(ApiResult.NOT_FOUND);
+        }
+        playerDatabase.disablePlayer(player, reason);
+        return new ApiResult<NoData>();
+      } catch (NoSuchAlgorithmException | InvalidKeySpecException | PasswordDatabaseException e) {
+        return CompletableFuture.completedFuture(new ApiResult<>(new ApiException("err.internal",
+            e)));
+      }
+    });
+  }
+  */
+
+  private PlayerDatabaseInfo getPlayerDatabaseInfo() {
+    PlayerDatabase playerDatabase = PlayerDatabaseFactory.getCurrentPlayerDatabase();
+    return new PlayerDatabaseInfo(
+        playerDatabase.supportsDisabling(),
+        !playerDatabase.supportsRolePasswords(),
+        playerDatabase.supportsAsymmetricalKeys());
+  }
+
+  private PlayerInfo getPlayerInfo(String name)
+      throws NoSuchAlgorithmException, InvalidKeySpecException, InterruptedException,
+          InvocationTargetException {
+    PlayerDatabase playerDatabase = PlayerDatabaseFactory.getCurrentPlayerDatabase();
+    if (!playerDatabase.isPlayerRegistered(name)) {
+      return null;
+    }
+    Player player = playerDatabase.getPlayer(name);
+    Role role = player.getRole();
+    boolean supportsBlocking = playerDatabase.supportsDisabling();
+    String blockedReason = "";
+    boolean blocked = false;
+    if (supportsBlocking) {
+      blockedReason = playerDatabase.getDisabledReason(player);
+      if (blockedReason.length() > 0) {
+        blocked = true;
+      }
+    }
+    boolean connected = false;
+    for (Player p : MapTool.getPlayerList()) {
+      if (name.equals(p.getName())) {
+        connected = true;
+        break;
+      }
+    }
+
+    return new PlayerInfo(name, role, blocked, blockedReason, connected);
+  }
+
+  private List<PlayerInfo> getPlayersInfo()
+      throws InterruptedException, InvocationTargetException, NoSuchAlgorithmException,
+          InvalidKeySpecException {
+    List<PlayerInfo> players = new ArrayList<>();
+    PlayerDatabase playerDatabase = PlayerDatabaseFactory.getCurrentPlayerDatabase();
+    for (Player p : playerDatabase.getAllPlayers()) {
+      players.add(getPlayerInfo(p.getName()));
+    }
+
+    return players;
+  }
+}

src/main/java/net/rptools/maptool/api/player/PlayerDatabaseInfo.java

@@ -0,0 +1,7 @@
+package net.rptools.maptool.api.player;
+
+import net.rptools.maptool.api.ApiData;
+
+public record PlayerDatabaseInfo(boolean supportsBlocking, boolean supportsIndividualPasswords,
+                                 boolean supportsAsymmetricalKeys) implements ApiData {
+}

src/main/java/net/rptools/maptool/api/player/PlayerInfo.java

@@ -0,0 +1,16 @@
+package net.rptools.maptool.api.player;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import net.rptools.maptool.api.ApiData;
+import net.rptools.maptool.model.player.Player.Role;
+
+public record PlayerInfo(
+    String name,
+    Role role,
+    boolean blocked,
+    String blockedReason,
+    boolean connected
+)  implements ApiData {
+
+}

src/main/java/net/rptools/maptool/api/util/ApiCall.java

@@ -0,0 +1,51 @@
+/*
+ * This software Copyright by the RPTools.net development team, and
+ * licensed under the Affero GPL Version 3 or, at your option, any later
+ * version.
+ *
+ * MapTool Source Code is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License * along with this source Code.  If not, please visit
+ * <http://www.gnu.org/licenses/> and specifically the Affero license
+ * text at <http://www.gnu.org/licenses/agpl.html>.
+ */
+package net.rptools.maptool.api.util;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import javax.swing.SwingUtilities;
+import net.rptools.maptool.api.ApiData;
+import net.rptools.maptool.api.ApiException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class ApiCall<T extends ApiData> {
+
+  private static final Logger log = LogManager.getLogger(ApiCall.class);
+
+  public CompletableFuture<ApiResult<T>> runOnSwingThread(Callable<T> callable) {
+    try {
+      if (SwingUtilities.isEventDispatchThread()) {
+        return CompletableFuture.completedFuture(doCall(callable));
+      } else {
+        return CompletableFuture.supplyAsync(() -> doCall(callable));
+      }
+    } catch (Exception e) {
+      log.error(e);
+      return CompletableFuture.completedFuture(
+          new ApiResult<>(new ApiException("err.internal", e)));
+    }
+  }
+
+  private ApiResult<T> doCall(Callable<T> callable) {
+    try {
+      return new ApiResult<T>(callable.call());
+    } catch (Exception e) {
+      log.error(e);
+      return new ApiResult<>(new ApiException("err.internal", e));
+    }
+  }
+}