515 lines
21 KiB
Java
515 lines
21 KiB
Java
/*
|
|
* Copyright (c) 2018 univento.eu - All rights reserved
|
|
* You are not allowed to use, distribute or modify this code
|
|
*/
|
|
|
|
package eu.univento.commons.player;
|
|
|
|
import eu.univento.commons.Commons;
|
|
import eu.univento.commons.player.ban.BanData;
|
|
import eu.univento.commons.player.ban.BanReason;
|
|
import eu.univento.commons.player.currency.CurrencyType;
|
|
import eu.univento.commons.player.kick.KickData;
|
|
import eu.univento.commons.player.kick.KickReason;
|
|
import eu.univento.commons.player.language.Language;
|
|
import eu.univento.commons.player.mute.MuteData;
|
|
import eu.univento.commons.player.mute.MuteReason;
|
|
import eu.univento.commons.player.rank.Group;
|
|
import eu.univento.commons.player.rank.Rank;
|
|
import eu.univento.commons.player.ranking.Ranking;
|
|
import eu.univento.commons.player.settings.PlayerSettings;
|
|
import eu.univento.commons.player.user.UserInformation;
|
|
import eu.univento.commons.player.warn.WarnData;
|
|
import eu.univento.commons.player.warn.WarnReason;
|
|
import io.vertx.core.json.JsonObject;
|
|
import io.vertx.ext.mongo.MongoClient;
|
|
import lombok.Getter;
|
|
|
|
import java.time.Instant;
|
|
import java.util.*;
|
|
import java.util.concurrent.*;
|
|
import java.util.logging.Level;
|
|
|
|
/**
|
|
* @author joethei
|
|
* @version 1.5
|
|
*/
|
|
|
|
@Getter
|
|
public class DatabasePlayer {
|
|
|
|
private UUID uuid;
|
|
private String name;
|
|
|
|
private JsonObject json;
|
|
|
|
private Rank rank;
|
|
private PlayerSettings settings;
|
|
private Language language;
|
|
private boolean muted;
|
|
|
|
private ScheduledFuture<?> updateFuture;
|
|
|
|
public DatabasePlayer(UUID uuid) {
|
|
this.uuid = uuid;
|
|
}
|
|
|
|
public DatabasePlayer(String name) {
|
|
UserInformation.get(name).whenComplete((userInformation, throwable) -> new DatabasePlayer(UUID.fromString(userInformation.getUuid())));
|
|
}
|
|
|
|
public void load(String host) {
|
|
Commons.getCommons().getDatabaseManager().getMongoDB().getClient().find("players", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if(res.succeeded()) {
|
|
if(res.result().isEmpty()) insert(host);
|
|
}else {
|
|
Commons.getCommons().getLogger().log(Level.SEVERE, res.cause().getMessage());
|
|
res.cause().printStackTrace();
|
|
}
|
|
});
|
|
getRankAsync().whenComplete((rank1, throwable) -> rank = rank1);
|
|
getSettingsAsync().whenComplete((playerSettings, throwable) -> settings = playerSettings);
|
|
isMutedAsync().whenComplete((aBoolean, throwable) -> muted = aBoolean);
|
|
getLanguageAsync().whenComplete((language1, throwable) -> language = language1);
|
|
|
|
Commons.getCommons().getDatabaseManager().getRedis().getClient().get("Name:" + uuid.toString(), res -> {
|
|
if(res.succeeded()) {
|
|
name = res.result();
|
|
}else {
|
|
UserInformation.get(uuid.toString()).whenComplete((userInformation, throwable) -> {
|
|
name = userInformation.getUsername();
|
|
Commons.getCommons().getDatabaseManager().getRedis().getClient().set("Name:" + uuid.toString(), name, event -> {
|
|
if(event.failed()) event.cause().printStackTrace();
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
|
|
Runnable updater = this::update;
|
|
updateFuture = scheduler.scheduleAtFixedRate(updater, 5, 5, TimeUnit.MINUTES);
|
|
}
|
|
|
|
public void save() {
|
|
updateFuture.cancel(true);
|
|
}
|
|
|
|
private void update() {
|
|
Commons.getCommons().getDatabaseManager().getMongoDB().getClient().findOne("players", new JsonObject().put("uuid", uuid.toString()), null, res -> {
|
|
if(res.failed()) res.cause().printStackTrace();
|
|
json = res.result();
|
|
});
|
|
}
|
|
|
|
//TODO: add more stuff
|
|
private void insert(String hostname) {
|
|
JsonObject social = new JsonObject().put("tsID", "null").put("boardID", 0);
|
|
JsonObject currency = new JsonObject().put("vents", 0);
|
|
|
|
JsonObject generalSettings = new JsonObject();
|
|
JsonObject socialSettings = new JsonObject().put("partyRequests", true).put("friendRequests", true).put("friendJump", true).put("clanRequests", true).put("tsMove", true);
|
|
JsonObject minigamesSettings = new JsonObject();
|
|
|
|
JsonObject settings = new JsonObject().put("general", generalSettings).put("social", socialSettings).put("minigames", minigamesSettings).put("nicked", false).put("language", Locale.ENGLISH.getLanguage());
|
|
|
|
JsonObject statistics = new JsonObject();
|
|
JsonObject friends = new JsonObject();
|
|
JsonObject history = new JsonObject().put(Instant.now().toString(), "PreIntro");
|
|
JsonObject items = new JsonObject();
|
|
|
|
JsonObject json = new JsonObject().put("uuid", uuid.toString()).put("lastName", name).put("rank", Rank.Player.name()).put("firstLogin", Instant.now()).put("lastLogin", Instant.now()).put("lastOnline", Instant.now()).put("onlineTime", 0L)
|
|
.put("lastIP", hostname).put("social", social).put("currency", currency).put("settings", settings).put("statistics", statistics).put("friends", friends).put("history", history).put("items", items);
|
|
|
|
|
|
Commons.getCommons().getDatabaseManager().getMongoDB().getClient().insert("players", json, res -> {
|
|
if(res.failed()) {
|
|
Commons.getCommons().getLogger().log(Level.SEVERE, res.cause().getMessage());
|
|
res.cause().printStackTrace();
|
|
}
|
|
});
|
|
}
|
|
|
|
public Language getLanguage() {
|
|
return Language.getLanguage(getSettings().getLanguage());
|
|
}
|
|
|
|
public CompletableFuture<Language> getLanguageAsync() {
|
|
CompletableFuture<Language> future = new CompletableFuture<>();
|
|
getSettingsAsync().whenComplete((playerSettings, throwable) -> future.complete(Language.getLanguage(playerSettings.getLanguage())));
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<PlayerSettings> getSettingsAsync() {
|
|
CompletableFuture<PlayerSettings> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) ->
|
|
future.complete(new PlayerSettings(this, entries.getJsonObject("Settings"))));
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Ranking> getRanking() {
|
|
CompletableFuture<Ranking> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) ->
|
|
future.complete(Ranking.valueOf(entries.getString("ranking"))));
|
|
return future;
|
|
}
|
|
|
|
public void ban(BanReason reason, UUID banner, String customMessage, String proof) {
|
|
getAllBans().whenComplete((banData, throwable) -> {
|
|
int i = 0;
|
|
if (banData.size() > 1) {
|
|
for (BanData ban : banData) {
|
|
i = +ban.getReason().getValue();
|
|
}
|
|
}
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.add(Calendar.DAY_OF_YEAR, reason.getValue() + i);
|
|
JsonObject obj = new JsonObject().put("uuid", uuid.toString())
|
|
.put("date", calendar.getTime())
|
|
.put("reason", reason.name())
|
|
.put("banner", banner.toString())
|
|
.put("customMessage", customMessage)
|
|
.put("proof", proof);
|
|
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.insert("bans", obj, res -> {
|
|
if (res.failed()) res.cause().printStackTrace();
|
|
});
|
|
});
|
|
|
|
}
|
|
|
|
public CompletableFuture<BanData> getBan() {
|
|
CompletableFuture<BanData> future = new CompletableFuture<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.findOne("bans", new JsonObject().put("uuid", uuid.toString()), null, res -> {
|
|
if(res.failed()) future.complete(null);
|
|
if(res.result() == null) future.complete(null);
|
|
JsonObject result = res.result();
|
|
if(result.isEmpty()) future.complete(null);
|
|
BanData data = new BanData(BanReason.valueOf(result.getString("reason")),
|
|
UUID.fromString(result.getString("banner")),
|
|
result.getString("customMessage"),
|
|
result.getInstant("date"),
|
|
result.getString("proof"));
|
|
future.complete(data);
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Boolean> isBanned() {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
Commons.getCommons().getDatabaseManager().getMongoDB().getClient().find("bans", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if(res.succeeded()) {
|
|
getBan().whenComplete((banData, throwable) -> future.complete(banData != null && !Instant.now().isAfter(banData.getUnbanDate())));
|
|
|
|
}else future.complete(false);
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Collection<BanData>> getAllBans() {
|
|
CompletableFuture<Collection<BanData>> future = new CompletableFuture<>();
|
|
Collection<BanData> data = new LinkedList<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.find("bans", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if (res.succeeded()) {
|
|
for (JsonObject json : res.result()) {
|
|
data.add(new BanData(BanReason.valueOf(json.getString("reason")),
|
|
UUID.fromString(json.getString("banner")),
|
|
json.getString("customMessage"),
|
|
json.getInstant("date"),
|
|
json.getString("proof")));
|
|
}
|
|
future.complete(data);
|
|
}
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public void warn(WarnReason reason, String warner, String proof) {
|
|
JsonObject obj = new JsonObject().put("uuid", uuid.toString()).put("reason", reason.getName()).put("warner", warner).put("date", Instant.now()).put("proof", proof);
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.insert("warns", obj, res -> {
|
|
if (res.failed()) {
|
|
try {
|
|
throw res.cause();
|
|
} catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
client.close();
|
|
}
|
|
|
|
public CompletableFuture<Boolean> isWarned() {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.findOne("warns", new JsonObject().put("uuid", uuid.toString()), null, res -> {
|
|
if (res.succeeded()) {
|
|
JsonObject json = res.result();
|
|
future.complete(json != null && Instant.now().isAfter(json.getInstant("date")));
|
|
}
|
|
});
|
|
client.close();
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Collection<WarnData>> getAllWarns() {
|
|
CompletableFuture<Collection<WarnData>> future = new CompletableFuture<>();
|
|
Collection<WarnData> data = new LinkedList<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.find("warns", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if (res.succeeded()) {
|
|
for (JsonObject json : res.result()) {
|
|
data.add(new WarnData(WarnReason.valueOf(json.getString("reason")),
|
|
UUID.fromString(json.getString("warner")),
|
|
json.getInstant("date"),
|
|
json.getString("proof")));
|
|
}
|
|
future.complete(data);
|
|
}
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public void kick(UUID kicker, KickReason reason) {
|
|
JsonObject obj = new JsonObject().put("uuid", uuid.toString()).put("reason", reason.name()).put("kicker", kicker.toString()).put("date", Instant.now());
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.insert("kicks", obj, res -> {
|
|
if (res.failed()) {
|
|
try {
|
|
throw res.cause();
|
|
} catch (Throwable throwable) {
|
|
throwable.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public CompletableFuture<Collection<KickData>> getAllKicks() {
|
|
CompletableFuture<Collection<KickData>> future = new CompletableFuture<>();
|
|
Collection<KickData> data = new LinkedList<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.find("kicks", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if (res.succeeded()) {
|
|
for (JsonObject json : res.result()) {
|
|
data.add(new KickData(KickReason.valueOf(json.getString("reason")),
|
|
json.getInstant("date"),
|
|
UUID.fromString("kicker")));
|
|
}
|
|
future.complete(data);
|
|
}
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public void mute(UUID muter, MuteReason reason) {
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
getAllMutes().whenComplete((muteData, throwable) -> {
|
|
int i = 0;
|
|
if (muteData.size() > 1) {
|
|
for (MuteData mute : muteData) i = +mute.getReason().getValue();
|
|
}
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.add(Calendar.DAY_OF_YEAR, reason.getValue() + i);
|
|
JsonObject obj = new JsonObject().put("uuid", uuid.toString())
|
|
.put("reason", reason.name())
|
|
.put("muter", muter.toString())
|
|
.put("date", calendar.getTime());
|
|
client.insert("mutes", obj, res -> {
|
|
if (res.failed()) {
|
|
try {
|
|
throw res.cause();
|
|
} catch (Throwable throwable1) {
|
|
throwable1.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
public CompletableFuture<Boolean> isMutedAsync() {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
getMute().whenComplete((muteData, throwable) -> future.complete(muteData != null && !Instant.now().isAfter(muteData.getDate())));
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<MuteData> getMute() {
|
|
CompletableFuture<MuteData> future = new CompletableFuture<>();
|
|
getAllMutes().whenComplete((muteData, throwable) -> {
|
|
for (MuteData data : muteData) {
|
|
if (Instant.now().isBefore(data.getDate())) future.complete(data);
|
|
}
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Collection<MuteData>> getAllMutes() {
|
|
CompletableFuture<Collection<MuteData>> future = new CompletableFuture<>();
|
|
Collection<MuteData> data = new LinkedList<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.find("mutes", new JsonObject().put("uuid", uuid.toString()), res -> {
|
|
if (res.succeeded()) {
|
|
for (JsonObject json : res.result()) {
|
|
data.add(new MuteData(MuteReason.valueOf(json.getString("reason")),
|
|
UUID.fromString(json.getString("uuid")),
|
|
UUID.fromString(json.getString("muter")),
|
|
json.getInstant("date")));
|
|
}
|
|
future.complete(data);
|
|
}
|
|
});
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Rank> getRankAsync() {
|
|
CompletableFuture<Rank> future = new CompletableFuture<>();
|
|
getStringFromDatabase("rank").whenComplete((s, throwable) -> future.complete(Rank.valueOf(s)));
|
|
return future;
|
|
}
|
|
|
|
public void setRank(Rank rank) {
|
|
setInDatabase("rank", rank.name());
|
|
}
|
|
|
|
public boolean isAllowed(Rank rank) {
|
|
return getRank().getValue() >= rank.getValue();
|
|
}
|
|
|
|
public CompletableFuture<Boolean> isAllowedAsync(Rank rank) {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
getRankAsync().whenComplete((rank1, throwable) -> future.complete(rank1.getValue() >= rank.getValue()));
|
|
return future;
|
|
}
|
|
|
|
public boolean isAllowed(Group group) {
|
|
return getRank().getGroup() == group;
|
|
}
|
|
|
|
public CompletableFuture<Boolean> isAllowedAsync(Group group) {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
getRankAsync().whenComplete((rank1, throwable) -> future.complete(rank1.getGroup() == group));
|
|
return future;
|
|
}
|
|
|
|
public boolean isTeamMember() {
|
|
return isAllowed(Rank.Sound);
|
|
}
|
|
|
|
public CompletableFuture<Boolean> hasPlayedBefore() {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.findOne("players", new JsonObject().put("uuid", uuid.toString()), null, res -> future.complete(res.succeeded()));
|
|
|
|
return future;
|
|
}
|
|
|
|
public void buy(CurrencyType type, int price) {
|
|
getCurrency(type).whenComplete((integer, throwable) -> setCurrency(type, integer - price));
|
|
}
|
|
|
|
private void setCurrency(CurrencyType type, int currency) {
|
|
setInDatabase(type.getName(), currency);
|
|
}
|
|
|
|
public CompletableFuture<Integer> getCurrency(CurrencyType type) {
|
|
return getIntegerFromDatabase(type.getName());
|
|
}
|
|
|
|
public void addCurrency(CurrencyType type, int amount) {
|
|
getCurrency(type).whenComplete((integer, throwable) -> setCurrency(type, integer + amount));
|
|
}
|
|
|
|
public void setTSID(String id) {
|
|
setInDatabase("tsid", id);
|
|
}
|
|
|
|
public CompletableFuture<Instant> getFirstLogin() {
|
|
return getInstantFromDatabase("firstLogin");
|
|
}
|
|
|
|
public CompletableFuture<Instant> getLastLogin() {
|
|
return getInstantFromDatabase("lastLogin");
|
|
}
|
|
|
|
public CompletableFuture<Instant> getLastOnline() {
|
|
return getInstantFromDatabase("lastOnline");
|
|
}
|
|
|
|
public CompletableFuture<String> getLastIP() {
|
|
return getStringFromDatabase("lastIP");
|
|
}
|
|
|
|
public CompletableFuture<String> getTSID() {
|
|
return getStringFromDatabase("tsID");
|
|
}
|
|
|
|
public CompletableFuture<Integer> getTimesJoined() {
|
|
return getIntegerFromDatabase("timesJoined");
|
|
}
|
|
|
|
public CompletableFuture<Long> getOnlineTime() {
|
|
return getLongFromDatabase("OnlineTime");
|
|
}
|
|
|
|
public void setOnlineTime(long time) {
|
|
setInDatabase("onlineTime", time);
|
|
}
|
|
|
|
|
|
public CompletableFuture<Integer> getBoardID() {
|
|
return getIntegerFromDatabase("boardID");
|
|
}
|
|
|
|
public void setBoardID(int id) {
|
|
setInDatabase("boardID", id);
|
|
}
|
|
|
|
public void setInDatabase(String name, Object obj) {
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.updateCollection("players", new JsonObject().put("uuid", uuid.toString()), new JsonObject().put("$set", new JsonObject().put(name, obj)), res -> {
|
|
if(res.failed()) {
|
|
res.cause().printStackTrace();
|
|
}
|
|
});
|
|
update();
|
|
}
|
|
|
|
|
|
private CompletableFuture<String> getStringFromDatabase(String key) {
|
|
CompletableFuture<String> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) -> future.complete(entries.getString(key)));
|
|
return future;
|
|
}
|
|
|
|
private CompletableFuture<Long> getLongFromDatabase(String key) {
|
|
CompletableFuture<Long> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) -> future.complete(entries.getLong(key)));
|
|
return future;
|
|
}
|
|
|
|
private CompletableFuture<Integer> getIntegerFromDatabase(String key) {
|
|
CompletableFuture<Integer> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) -> future.complete(entries.getInteger(key)));
|
|
return future;
|
|
}
|
|
|
|
private CompletableFuture<Boolean> getBooleanFromDatabase(String key) {
|
|
CompletableFuture<Boolean> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) -> future.complete(entries.getBoolean(key)));
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<Instant> getInstantFromDatabase(String key) {
|
|
CompletableFuture<Instant> future = new CompletableFuture<>();
|
|
getObjectFromDatabase().whenComplete((entries, throwable) -> future.complete(entries.getInstant(key)));
|
|
return future;
|
|
}
|
|
|
|
public CompletableFuture<JsonObject> getObjectFromDatabase() {
|
|
CompletableFuture<JsonObject> future = new CompletableFuture<>();
|
|
MongoClient client = Commons.getCommons().getDatabaseManager().getMongoDB().getClient();
|
|
client.findOne("players", new JsonObject().put("uuid", uuid.toString()), null, res -> future.complete(res.result()));
|
|
return future;
|
|
}
|
|
} |