Upstream/Plan
1
0
Fork 0
mirror of https://github.com/plan-player-analytics/Plan.git synced 2024-06-26 22:54:47 +02:00
Code Issues Projects Releases Wiki Activity

Fixing IDEA code inspection issues

Browse Source 
- Removed MethodAnnotations use in ExtensionExtractor
- Refactored duplicate code in
  - BaseUserQueries
  - GeoInfoQueries
  - JoinAddressQueries
  - KillQueries
  - NicknameQueries
  - WebUserQueries
  - TopListQueries
This commit is contained in:
Aurora Lahtela 2022-06-05 16:59:35 +03:00
parent 245f002833
commit 71424fa2ec
17 changed files with 191 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionExtractor.java
View File

@ -45,7 +45,6 @@ public final class ExtensionExtractor {
private PluginInfo pluginInfo;
private List<TabInfo> tabInformation;
private List<InvalidateMethod> invalidMethods;
private MethodAnnotations methodAnnotations;
private Map<ExtensionMethod.ParameterType, ExtensionMethods> methods;
private Collection<Method> conditionalMethods;
private Collection<Tab> tabAnnotations;
@ -102,12 +101,9 @@ public final class ExtensionExtractor {
* @deprecated No longer used anywhere, no-op.
*/
@Deprecated
public void extractAnnotationInformation() {
// no-op
}
public void extractAnnotationInformation() {/* no-op */}
private void extractMethods() {
methodAnnotations = new MethodAnnotations();
methods = new EnumMap<>(ExtensionMethod.ParameterType.class);
methods.put(ExtensionMethod.ParameterType.SERVER_NONE, new ExtensionMethods());
methods.put(ExtensionMethod.ParameterType.PLAYER_STRING, new ExtensionMethods());
@ -132,55 +128,41 @@ public final class ExtensionExtractor {
method.getAnnotation(BooleanProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addBooleanMethod(method);
methodAnnotations.put(method.getMethod(), BooleanProvider.class, annotation);
});
method.getAnnotation(NumberProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addNumberMethod(method);
methodAnnotations.put(method.getMethod(), NumberProvider.class, annotation);
});
method.getAnnotation(DoubleProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addDoubleMethod(method);
methodAnnotations.put(method.getMethod(), DoubleProvider.class, annotation);
});
method.getAnnotation(PercentageProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addPercentageMethod(method);
methodAnnotations.put(method.getMethod(), PercentageProvider.class, annotation);
});
method.getAnnotation(StringProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addStringMethod(method);
methodAnnotations.put(method.getMethod(), StringProvider.class, annotation);
});
method.getAnnotation(TableProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addTableMethod(method);
methodAnnotations.put(method.getMethod(), TableProvider.class, annotation);
});
method.getAnnotation(GroupProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addGroupMethod(method);
methodAnnotations.put(method.getMethod(), GroupProvider.class, annotation);
});
method.getAnnotation(DataBuilderProvider.class).ifPresent(annotation -> {
validateMethod(method, annotation);
methods.get(method.getParameterType()).addDataBuilderMethod(method);
methodAnnotations.put(method.getMethod(), DataBuilderProvider.class, annotation);
});
method.getAnnotation(Conditional.class).ifPresent(annotation -> {
conditionalMethods.add(method.getMethod());
methodAnnotations.put(method.getMethod(), Conditional.class, annotation);
});
method.getAnnotation(Tab.class).ifPresent(annotation -> {
tabAnnotations.add(annotation);
methodAnnotations.put(method.getMethod(), Tab.class, annotation);
});
method.getAnnotation(Conditional.class).ifPresent(annotation -> conditionalMethods.add(method.getMethod()));
method.getAnnotation(Tab.class).ifPresent(tabAnnotations::add);
}
if (methodAnnotations.isEmpty()) {
if (methods.values().stream().allMatch(ExtensionMethods::isEmpty)) {
throw new IllegalArgumentException(extensionName + " class had no methods annotated with a Provider annotation");
}
@ -440,10 +422,12 @@ public final class ExtensionExtractor {
return tabInformation;
}
/**
* @deprecated During refactoring MethodAnnotations was removed. Using {@link ExtensionExtractor#getMethods()} instead.
*/
@Deprecated
public MethodAnnotations getMethodAnnotations() {
if (methodAnnotations == null) extractMethods();
return methodAnnotations;
return new MethodAnnotations();
}
public Map<ExtensionMethod.ParameterType, ExtensionMethods> getMethods() {
@ -455,4 +439,10 @@ public final class ExtensionExtractor {
if (invalidMethods == null) extractInvalidMethods();
return invalidMethods;
}
// Visible for testing
Collection<Method> getConditionalMethods() {
if (conditionalMethods == null) extractMethods();
return conditionalMethods;
}
}

11
Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionMethods.java
View File

@ -142,4 +142,15 @@ public class ExtensionMethods {
", dataBuilderProviders=" + dataBuilderProviders +
'}';
}
public boolean isEmpty() {
return booleanProviders.isEmpty()
&& numberProviders.isEmpty()
&& doubleProviders.isEmpty()
&& percentageProviders.isEmpty()
&& stringProviders.isEmpty()
&& tableProviders.isEmpty()
&& groupProviders.isEmpty()
&& dataBuilderProviders.isEmpty();
}
}

11
Plan/api/src/test/java/com/djrapitops/plan/extension/extractor/ExtensionExtractorTest.java
View File

@ -265,7 +265,7 @@ class ExtensionExtractorTest {
}
ExtensionExtractor underTest = new ExtensionExtractor(new Extension());
assertEquals("Extension.method did not have any associated Provider for Conditional.", assertThrows(IllegalArgumentException.class, underTest::validateAnnotations).getMessage());
assertEquals("Extension class had no methods annotated with a Provider annotation", assertThrows(IllegalArgumentException.class, underTest::validateAnnotations).getMessage());
}
@Test
@ -489,8 +489,13 @@ class ExtensionExtractorTest {
String expected = Stream.of(extension.getClass().getMethod("method").getAnnotation(Conditional.class))
.map(Conditional::value).findFirst().orElseThrow(AssertionError::new);
String result = underTest.getMethodAnnotations().getAnnotations(Conditional.class).stream()
.map(Conditional::value).findFirst().orElseThrow(AssertionError::new);
String result = underTest.getConditionalMethods().stream()
.map(method -> new ExtensionMethod(extension, method))
.map(extensionMethod -> extensionMethod.getAnnotation(Conditional.class))
.filter(Optional::isPresent)
.map(Optional::get)
.map(Conditional::value)
.findFirst().orElseThrow(AssertionError::new);
assertEquals(expected, result);
}

2
Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/mutators/TimeSegmentsMutator.java
View File

@ -27,7 +27,7 @@ import java.util.concurrent.TimeUnit;
public class TimeSegmentsMutator<T> {
List<TimeSegment<T>> segments;
private final List<TimeSegment<T>> segments;
public TimeSegmentsMutator(List<TimeSegment<T>> segments) {
this.segments = segments;

6
Plan/common/src/main/java/com/djrapitops/plan/storage/database/Database.java
View File

@ -66,7 +66,7 @@ public interface Database {
@Override
public Optional<T> processResults(ResultSet set) throws SQLException {
return set.next() ? Optional.of(rowExtractor.extract(set)) : Optional.empty();
return set.next() ? Optional.ofNullable(rowExtractor.extract(set)) : Optional.empty();
}
});
}
@ -80,7 +80,7 @@ public interface Database {
}
default <C extends Collection<T>, T> C queryCollection(String sql, RowExtractor<T> rowExtractor, Supplier<C> collectionConstructor, Object... parameters) {
return query(new QueryStatement<C>(sql) {
return query(new QueryStatement<C>(sql, 1000) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
QueryParameterSetter.setParameters(statement, parameters);
@ -102,7 +102,7 @@ public interface Database {
}
default <M extends Map<K, V>, K, V> M queryMap(String sql, MapRowExtractor<K, V> rowExtractor, Supplier<M> mapConstructor, Object... parameters) {
return query(new QueryStatement<M>(sql) {
return query(new QueryStatement<M>(sql, 100) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
QueryParameterSetter.setParameters(statement, parameters);

52
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/RowExtractors.java Normal file
View File

@ -0,0 +1,52 @@
/*
* This file is part of Player Analytics (Plan).
*
* Plan is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License v3 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Plan 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. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
*/
package com.djrapitops.plan.storage.database.queries;
import com.djrapitops.plan.identification.ServerUUID;
import java.util.UUID;
public class RowExtractors {
private RowExtractors() {}
public static RowExtractor<Integer> getInt(String columnName) {
return set -> {
int value = set.getInt(columnName);
return set.wasNull() ? null : value;
};
}
public static RowExtractor<Long> getLong(String columnName) {
return set -> {
long value = set.getLong(columnName);
return set.wasNull() ? null : value;
};
}
public static RowExtractor<String> getString(String columnName) {
return set -> set.getString(columnName);
}
public static RowExtractor<UUID> getUUID(String columnName) {
return set -> UUID.fromString(set.getString(columnName));
}
public static RowExtractor<ServerUUID> getServerUUID(String columnName) {
return set -> ServerUUID.fromString(set.getString(columnName));
}
}

14
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerCountQueries.java
View File

@ -439,17 +439,7 @@ public class PlayerCountQueries {
String sql = SELECT + "COUNT(1) as " + PLAYER_COUNT + FROM + UserInfoTable.TABLE_NAME +
WHERE + UserInfoTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
AND + UserInfoTable.OP + "=?";
return new QueryStatement<Integer>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setBoolean(2, true);
}
@Override
public Integer processResults(ResultSet set) throws SQLException {
return set.next() ? set.getInt(PLAYER_COUNT) : 0;
}
};
return db -> db.queryOptional(sql, set -> set.getInt(PLAYER_COUNT), serverUUID, true)
.orElse(0);
}
}

47
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/TopListQueries.java
View File

@ -18,14 +18,10 @@ package com.djrapitops.plan.storage.database.queries.analysis;
import com.djrapitops.plan.identification.ServerUUID;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
import com.djrapitops.plan.storage.database.sql.tables.SessionsTable;
import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Optional;
import static com.djrapitops.plan.storage.database.sql.building.Sql.*;
@ -49,26 +45,8 @@ public class TopListQueries {
LIMIT + "10" +
OFFSET + "?";
return new QueryStatement<Optional<TopListEntry<Long>>>(sql, 10) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
statement.setInt(4, n - 1);
}
@Override
public Optional<TopListEntry<Long>> processResults(ResultSet set) throws SQLException {
if (set.next()) {
return Optional.of(
new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("playtime"))
);
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, set -> new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("playtime")),
serverUUID, after, before, n - 1);
}
public static Query<Optional<TopListEntry<Long>>> fetchNthTop10ActivePlaytimePlayerOn(ServerUUID serverUUID, int n, long after, long before) {
@ -84,25 +62,8 @@ public class TopListQueries {
LIMIT + "10" +
OFFSET + "?";
return new QueryStatement<Optional<TopListEntry<Long>>>(sql, 10) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
statement.setInt(4, n - 1);
}
@Override
public Optional<TopListEntry<Long>> processResults(ResultSet set) throws SQLException {
if (set.next()) {
return Optional.of(
new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("active_playtime"))
);
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, set -> new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("active_playtime")),
serverUUID, after, before, n - 1);
}
public static class TopListEntry<T> {

105
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/BaseUserQueries.java
View File

@ -19,16 +19,17 @@ package com.djrapitops.plan.storage.database.queries.objects;
import com.djrapitops.plan.gathering.domain.BaseUser;
import com.djrapitops.plan.gathering.domain.UserInfo;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.queries.RowExtractors;
import com.djrapitops.plan.storage.database.sql.building.Select;
import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
import org.apache.commons.text.TextStringBuilder;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.Collection;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import static com.djrapitops.plan.storage.database.sql.building.Sql.*;
@ -53,25 +54,16 @@ public class BaseUserQueries {
public static Query<Collection<BaseUser>> fetchAllBaseUsers() {
String sql = Select.all(UsersTable.TABLE_NAME).toString();
return new QueryAllStatement<Collection<BaseUser>>(sql, 20000) {
@Override
public Collection<BaseUser> processResults(ResultSet set) throws SQLException {
return extractBaseUsers(set);
}
};
return db -> db.queryList(sql, BaseUserQueries::extractBaseUser);
}
private static Collection<BaseUser> extractBaseUsers(ResultSet set) throws SQLException {
Collection<BaseUser> users = new HashSet<>();
while (set.next()) {
UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID));
String name = set.getString(UsersTable.USER_NAME);
long registered = set.getLong(UsersTable.REGISTERED);
int kicked = set.getInt(UsersTable.TIMES_KICKED);
private static BaseUser extractBaseUser(ResultSet set) throws SQLException {
UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID));
String name = set.getString(UsersTable.USER_NAME);
long registered = set.getLong(UsersTable.REGISTERED);
int kicked = set.getInt(UsersTable.TIMES_KICKED);
users.add(new BaseUser(playerUUID, name, registered, kicked));
}
return users;
return new BaseUser(playerUUID, name, registered, kicked);
}
/**
@ -85,25 +77,7 @@ public class BaseUserQueries {
public static Query<Optional<BaseUser>> fetchBaseUserOfPlayer(UUID playerUUID) {
String sql = Select.all(UsersTable.TABLE_NAME).where(UsersTable.USER_UUID + "=?").toString();
return new QueryStatement<Optional<BaseUser>>(sql, 20000) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
}
@Override
public Optional<BaseUser> processResults(ResultSet set) throws SQLException {
if (set.next()) {
UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID));
String name = set.getString(UsersTable.USER_NAME);
long registered = set.getLong(UsersTable.REGISTERED);
int kicked = set.getInt(UsersTable.TIMES_KICKED);
return Optional.of(new BaseUser(playerUUID, name, registered, kicked));
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, BaseUserQueries::extractBaseUser, playerUUID);
}
public static Query<Set<Integer>> userIdsOfRegisteredBetween(long after, long before) {
@ -111,55 +85,23 @@ public class BaseUserQueries {
FROM + UsersTable.TABLE_NAME +
WHERE + UsersTable.REGISTERED + ">=?" +
AND + UsersTable.REGISTERED + "<=?";
return new QueryStatement<Set<Integer>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setLong(1, after);
statement.setLong(2, before);
}
@Override
public Set<Integer> processResults(ResultSet set) throws SQLException {
Set<Integer> userIds = new HashSet<>();
while (set.next()) {
userIds.add(set.getInt(UsersTable.ID));
}
return userIds;
}
};
return db -> db.querySet(sql, RowExtractors.getInt(UsersTable.ID), after, before);
}
public static Query<Optional<Long>> minimumRegisterDate() {
String sql = SELECT + min(UsersTable.REGISTERED) + " as min" +
FROM + UsersTable.TABLE_NAME;
return new QueryAllStatement<Optional<Long>>(sql) {
@Override
public Optional<Long> processResults(ResultSet set) throws SQLException {
if (set.next()) {
long min = set.getLong("min");
if (!set.wasNull()) return Optional.of(min);
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, RowExtractors.getLong("min"));
}
public static Query<Integer> fetchUserId(UUID playerUUID) {
// Visible for testing
public static Query<Optional<Integer>> fetchUserId(UUID playerUUID) {
String sql = Select.from(UsersTable.TABLE_NAME, UsersTable.ID)
.where(UsersTable.USER_UUID + "=?")
.toString();
return new QueryStatement<Integer>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
}
@Override
public Integer processResults(ResultSet set) throws SQLException {
return set.next() ? set.getInt(UsersTable.ID) : -1;
}
};
return db -> db.queryOptional(sql, RowExtractors.getInt(UsersTable.ID), playerUUID);
}
public static Query<Set<UUID>> fetchExistingUUIDs(Set<UUID> outOfPlayerUUIDs) {
@ -167,15 +109,6 @@ public class BaseUserQueries {
FROM + UsersTable.TABLE_NAME +
WHERE + UsersTable.USER_UUID + " IN ('" + new TextStringBuilder().appendWithSeparators(outOfPlayerUUIDs, "','").build() + "')";
return new QueryAllStatement<Set<UUID>>(sql) {
@Override
public Set<UUID> processResults(ResultSet set) throws SQLException {
Set<UUID> uuids = new HashSet<>();
while (set.next()) {
uuids.add(UUID.fromString(set.getString(UsersTable.USER_UUID)));
}
return uuids;
}
};
return db -> db.querySet(sql, RowExtractors.getUUID(UsersTable.USER_UUID));
}
}

91
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/GeoInfoQueries.java
View File

@ -20,7 +20,7 @@ import com.djrapitops.plan.gathering.domain.GeoInfo;
import com.djrapitops.plan.identification.ServerUUID;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.queries.RowExtractors;
import com.djrapitops.plan.storage.database.sql.tables.GeoInfoTable;
import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
import com.djrapitops.plan.storage.database.sql.tables.UserInfoTable;
@ -28,7 +28,6 @@ import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
import com.djrapitops.plan.utilities.java.Lists;
import org.apache.commons.text.TextStringBuilder;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
@ -59,7 +58,7 @@ public class GeoInfoQueries {
FROM + GeoInfoTable.TABLE_NAME + " g" +
INNER_JOIN + UsersTable.TABLE_NAME + " u on g.user_id=u.id";
return new QueryAllStatement<Map<UUID, List<GeoInfo>>>(sql, 50000) {
return new QueryAllStatement<Map<UUID, List<GeoInfo>>>(sql, 10000) {
@Override
public Map<UUID, List<GeoInfo>> processResults(ResultSet set) throws SQLException {
return extractGeoInformation(set);
@ -93,23 +92,13 @@ public class GeoInfoQueries {
WHERE + GeoInfoTable.USER_ID + "=" + UsersTable.SELECT_USER_ID +
GROUP_BY + GeoInfoTable.GEOLOCATION;
return new QueryStatement<List<GeoInfo>>(sql, 100) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
}
return db -> db.queryList(sql, GeoInfoQueries::extractGeoInfo, playerUUID);
}
@Override
public List<GeoInfo> processResults(ResultSet set) throws SQLException {
List<GeoInfo> geoInfo = new ArrayList<>();
while (set.next()) {
String geolocation = set.getString(GeoInfoTable.GEOLOCATION);
long lastUsed = set.getLong(GeoInfoTable.LAST_USED);
geoInfo.add(new GeoInfo(geolocation, lastUsed));
}
return geoInfo;
}
};
private static GeoInfo extractGeoInfo(ResultSet set) throws SQLException {
String geolocation = set.getString(GeoInfoTable.GEOLOCATION);
long lastUsed = set.getLong(GeoInfoTable.LAST_USED);
return new GeoInfo(geolocation, lastUsed);
}
public static Query<Map<String, Integer>> networkGeolocationCounts() {
@ -124,16 +113,14 @@ public class GeoInfoQueries {
WHERE + "b." + GeoInfoTable.LAST_USED + IS_NULL +
GROUP_BY + "a." + GeoInfoTable.GEOLOCATION;
return new QueryAllStatement<Map<String, Integer>>(sql) {
@Override
public Map<String, Integer> processResults(ResultSet set) throws SQLException {
Map<String, Integer> geolocationCounts = new HashMap<>();
while (set.next()) {
geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c"));
}
return geolocationCounts;
}
};
return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts);
}
private static void extractGeolocationCounts(ResultSet set, Map<String, Integer> geolocationCounts) throws SQLException {
geolocationCounts.put(
set.getString(GeoInfoTable.GEOLOCATION),
set.getInt("c")
);
}
public static Query<Map<String, Integer>> networkGeolocationCounts(Collection<Integer> userIds) {
@ -151,16 +138,7 @@ public class GeoInfoQueries {
new TextStringBuilder().appendWithSeparators(userIds, ",").build() + ")" +
GROUP_BY + "a." + GeoInfoTable.GEOLOCATION;
return new QueryAllStatement<Map<String, Integer>>(sql) {
@Override
public Map<String, Integer> processResults(ResultSet set) throws SQLException {
Map<String, Integer> geolocationCounts = new HashMap<>();
while (set.next()) {
geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c"));
}
return geolocationCounts;
}
};
return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts);
}
public static Query<Map<String, Integer>> serverGeolocationCounts(ServerUUID serverUUID) {
@ -178,34 +156,14 @@ public class GeoInfoQueries {
AND + "ui." + UserInfoTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
GROUP_BY + "a." + GeoInfoTable.GEOLOCATION;
return new QueryStatement<Map<String, Integer>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
}
@Override
public Map<String, Integer> processResults(ResultSet set) throws SQLException {
Map<String, Integer> geolocationCounts = new HashMap<>();
while (set.next()) {
geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c"));
}
return geolocationCounts;
}
};
return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts, serverUUID);
}
public static Query<List<String>> uniqueGeolocations() {
String sql = SELECT + GeoInfoTable.GEOLOCATION + FROM + GeoInfoTable.TABLE_NAME +
ORDER_BY + GeoInfoTable.GEOLOCATION + " ASC";
return new QueryAllStatement<List<String>>(sql) {
@Override
public List<String> processResults(ResultSet set) throws SQLException {
List<String> geolocations = new ArrayList<>();
while (set.next()) geolocations.add(set.getString(GeoInfoTable.GEOLOCATION));
return geolocations;
}
};
return db -> db.queryList(sql, RowExtractors.getString(GeoInfoTable.GEOLOCATION));
}
public static Query<Set<Integer>> userIdsOfPlayersWithGeolocations(List<String> selected) {
@ -216,13 +174,6 @@ public class GeoInfoQueries {
" IN ('" +
new TextStringBuilder().appendWithSeparators(selected, "','") +
"')";
return new QueryAllStatement<Set<Integer>>(sql) {
@Override
public Set<Integer> processResults(ResultSet set) throws SQLException {
Set<Integer> geolocations = new HashSet<>();
while (set.next()) geolocations.add(set.getInt(UsersTable.ID));
return geolocations;
}
};
return db -> db.querySet(sql, RowExtractors.getInt(UsersTable.ID));
}
}

49
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java
View File

@ -20,12 +20,12 @@ import com.djrapitops.plan.identification.ServerUUID;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.queries.RowExtractors;
import com.djrapitops.plan.storage.database.sql.tables.JoinAddressTable;
import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
import com.djrapitops.plan.storage.database.sql.tables.SessionsTable;
import org.apache.commons.text.TextStringBuilder;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
@ -50,16 +50,11 @@ public class JoinAddressQueries {
GROUP_BY + JoinAddressTable.JOIN_ADDRESS +
ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC";
return new QueryAllStatement<Map<String, Integer>>(selectLatestJoinAddresses, 100) {
@Override
public Map<String, Integer> processResults(ResultSet set) throws SQLException {
Map<String, Integer> joinAddresses = new TreeMap<>();
while (set.next()) {
joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total"));
}
return joinAddresses;
}
};
return db -> db.queryMap(selectLatestJoinAddresses, JoinAddressQueries::extractJoinAddressCounts, TreeMap::new);
}
private static void extractJoinAddressCounts(ResultSet set, Map<String, Integer> joinAddresses) throws SQLException {
joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total"));
}
public static Query<Map<String, Integer>> latestJoinAddresses(ServerUUID serverUUID) {
@ -76,27 +71,15 @@ public class JoinAddressQueries {
GROUP_BY + JoinAddressTable.JOIN_ADDRESS +
ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC";
return new QueryStatement<Map<String, Integer>>(selectLatestJoinAddresses, 100) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
}
@Override
public Map<String, Integer> processResults(ResultSet set) throws SQLException {
Map<String, Integer> joinAddresses = new TreeMap<>();
while (set.next()) {
joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total"));
}
return joinAddresses;
}
};
return db -> db.queryMap(selectLatestJoinAddresses, JoinAddressQueries::extractJoinAddressCounts, TreeMap::new, serverUUID);
}
public static QueryStatement<List<String>> allJoinAddresses() {
String sql = SELECT + JoinAddressTable.JOIN_ADDRESS +
FROM + JoinAddressTable.TABLE_NAME +
ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC";
return new QueryAllStatement<List<String>>(sql, 100) {
@Override
public List<String> processResults(ResultSet set) throws SQLException {
@ -125,18 +108,8 @@ public class JoinAddressQueries {
new TextStringBuilder().appendWithSeparators(joinAddresses.stream().map(item -> '?').iterator(), ",") +
')'; // Don't append addresses directly, SQL injection hazard
return new QueryStatement<Set<Integer>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
for (int i = 0; i < joinAddresses.size(); i++) {
statement.setString(i + 1, joinAddresses.get(i).toLowerCase());
}
}
@Override
public Set<Integer> processResults(ResultSet set) throws SQLException {
return UserInfoQueries.extractUserIds(set, SessionsTable.USER_ID);
}
};
return db -> db.querySet(sql, RowExtractors.getInt(SessionsTable.USER_ID), joinAddresses
.stream().map(String::toLowerCase)
.toArray());
}
}

79
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/KillQueries.java
View File

@ -22,6 +22,7 @@ import com.djrapitops.plan.identification.Server;
import com.djrapitops.plan.identification.ServerUUID;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.queries.RowExtractors;
import com.djrapitops.plan.storage.database.sql.tables.KillsTable;
import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
import com.djrapitops.plan.storage.database.sql.tables.SessionsTable;
@ -179,19 +180,9 @@ public class KillQueries {
WHERE + KillsTable.SERVER_UUID + "=?" +
AND + KillsTable.DATE + ">=?" +
AND + KillsTable.DATE + "<=?";
return new QueryStatement<Long>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
}
@Override
public Long processResults(ResultSet set) throws SQLException {
return set.next() ? set.getLong("count") : 0L;
}
};
return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before)
.orElse(0L);
}
public static Query<Double> averageKDR(long after, long before, ServerUUID serverUUID) {
@ -246,19 +237,10 @@ public class KillQueries {
WHERE + SessionsTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
AND + SessionsTable.SESSION_END + ">=?" +
AND + SessionsTable.SESSION_START + "<=?";
return new QueryStatement<Long>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
}
@Override
public Long processResults(ResultSet set) throws SQLException {
return set.next() ? set.getLong("count") : 0L;
}
};
return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before)
.orElse(0L);
}
public static Query<Long> deathCount(long after, long before, ServerUUID serverUUID) {
@ -267,19 +249,8 @@ public class KillQueries {
WHERE + SessionsTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
AND + SessionsTable.SESSION_END + ">=?" +
AND + SessionsTable.SESSION_START + "<=?";
return new QueryStatement<Long>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
}
@Override
public Long processResults(ResultSet set) throws SQLException {
return set.next() ? set.getLong("count") : 0L;
}
};
return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before)
.orElse(0L);
}
public static Query<List<String>> topWeaponsOfServer(long after, long before, ServerUUID serverUUID, int limit) {
@ -293,22 +264,7 @@ public class KillQueries {
FROM + '(' + innerSQL + ") q1" +
ORDER_BY + "kills DESC LIMIT ?";
return new QueryStatement<List<String>>(sql, limit) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, serverUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
statement.setInt(4, limit);
}
@Override
public List<String> processResults(ResultSet set) throws SQLException {
List<String> weapons = new ArrayList<>();
while (set.next()) weapons.add(set.getString(KillsTable.WEAPON));
return weapons;
}
};
return db -> db.queryList(sql, RowExtractors.getString(KillsTable.WEAPON), serverUUID, after, before, limit);
}
public static Query<List<String>> topWeaponsOfPlayer(long after, long before, UUID playerUUID, int limit) {
@ -322,21 +278,6 @@ public class KillQueries {
FROM + '(' + innerSQL + ") q1" +
ORDER_BY + "kills DESC LIMIT ?";
return new QueryStatement<List<String>>(sql, limit) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
statement.setLong(2, after);
statement.setLong(3, before);
statement.setInt(4, limit);
}
@Override
public List<String> processResults(ResultSet set) throws SQLException {
List<String> weapons = new ArrayList<>();
while (set.next()) weapons.add(set.getString(KillsTable.WEAPON));
return weapons;
}
};
return db -> db.queryList(sql, RowExtractors.getString(KillsTable.WEAPON), playerUUID, after, before, limit);
}
}

55
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/NicknameQueries.java
View File

@ -20,12 +20,10 @@ import com.djrapitops.plan.delivery.domain.Nickname;
import com.djrapitops.plan.identification.ServerUUID;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.sql.tables.NicknamesTable;
import com.djrapitops.plan.utilities.java.Lists;
import com.djrapitops.plan.utilities.java.Maps;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
@ -84,32 +82,24 @@ public class NicknameQueries {
AND + NicknamesTable.SERVER_UUID + "=?" +
GROUP_BY + NicknamesTable.USER_UUID;
String sql = SELECT +
NicknamesTable.LAST_USED + ',' + NicknamesTable.NICKNAME +
NicknamesTable.LAST_USED + ',' +
NicknamesTable.NICKNAME + ',' +
NicknamesTable.SERVER_UUID +
FROM + NicknamesTable.TABLE_NAME +
WHERE + NicknamesTable.USER_UUID + "=?" +
AND + NicknamesTable.SERVER_UUID + "=?" +
AND + NicknamesTable.LAST_USED + "=(" + subQuery + ')';
return new QueryStatement<Optional<Nickname>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
statement.setString(2, serverUUID.toString());
statement.setString(3, playerUUID.toString());
statement.setString(4, serverUUID.toString());
}
@Override
public Optional<Nickname> processResults(ResultSet set) throws SQLException {
if (set.next()) {
return Optional.of(new Nickname(
set.getString(NicknamesTable.NICKNAME),
set.getLong(NicknamesTable.LAST_USED),
serverUUID
));
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, NicknameQueries::extractNickname,
playerUUID, serverUUID, playerUUID, serverUUID);
}
private static Nickname extractNickname(ResultSet set) throws SQLException {
return new Nickname(
set.getString(NicknamesTable.NICKNAME),
set.getLong(NicknamesTable.LAST_USED),
ServerUUID.fromString(set.getString(NicknamesTable.SERVER_UUID))
);
}
public static Query<List<Nickname>> fetchNicknameDataOfPlayer(UUID playerUUID) {
@ -120,24 +110,7 @@ public class NicknameQueries {
FROM + NicknamesTable.TABLE_NAME +
WHERE + NicknamesTable.USER_UUID + "=?";
return new QueryStatement<List<Nickname>>(sql, 5000) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerUUID.toString());
}
@Override
public List<Nickname> processResults(ResultSet set) throws SQLException {
List<Nickname> nicknames = new ArrayList<>();
while (set.next()) {
ServerUUID serverUUID = ServerUUID.fromString(set.getString(NicknamesTable.SERVER_UUID));
String nickname = set.getString(NicknamesTable.NICKNAME);
nicknames.add(new Nickname(nickname, set.getLong(NicknamesTable.LAST_USED), serverUUID));
}
return nicknames;
}
};
return db -> db.queryList(sql, NicknameQueries::extractNickname, playerUUID);
}
}

147
Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/WebUserQueries.java
View File

@ -19,17 +19,16 @@ package com.djrapitops.plan.storage.database.queries.objects;
import com.djrapitops.plan.delivery.domain.WebUser;
import com.djrapitops.plan.delivery.domain.auth.User;
import com.djrapitops.plan.storage.database.queries.Query;
import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
import com.djrapitops.plan.storage.database.queries.QueryStatement;
import com.djrapitops.plan.storage.database.sql.tables.CookieTable;
import com.djrapitops.plan.storage.database.sql.tables.SecurityTable;
import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.*;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import static com.djrapitops.plan.storage.database.sql.building.Sql.*;
@ -47,129 +46,36 @@ public class WebUserQueries {
public static Query<Optional<User>> fetchUser(String username) {
String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME +
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID +
WHERE + SecurityTable.USERNAME + "=? LIMIT 1";
return new QueryStatement<Optional<User>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, username);
}
WHERE + SecurityTable.USERNAME + "=?" + LIMIT + "1";
@Override
public Optional<User> processResults(ResultSet set) throws SQLException {
if (set.next()) {
String linkedTo = set.getString(UsersTable.USER_NAME);
UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null;
String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH);
int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL);
List<String> permissions = WebUser.getPermissionsForLevel(permissionLevel);
return Optional.of(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions));
}
return Optional.empty();
}
};
return db -> db.queryOptional(sql, WebUserQueries::extractUser, username);
}
public static Query<Optional<User>> fetchUserLinkedTo(String playerName) {
String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME +
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID +
WHERE + UsersTable.USER_NAME + "=? LIMIT 1";
return new QueryStatement<Optional<User>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, playerName);
}
@Override
public Optional<User> processResults(ResultSet set) throws SQLException {
if (set.next()) {
String linkedTo = set.getString(UsersTable.USER_NAME);
UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null;
String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH);
int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL);
List<String> permissions = WebUser.getPermissionsForLevel(permissionLevel);
return Optional.of(new User(playerName, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions));
}
return Optional.empty();
}
};
WHERE + UsersTable.USER_NAME + "=?" + LIMIT + "1";
return db -> db.queryOptional(sql, WebUserQueries::extractUser, playerName);
}
public static Query<Optional<User>> fetchUser(UUID linkedToUUID) {
String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME +
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID +
WHERE + SecurityTable.LINKED_TO + "=? LIMIT 1";
return new QueryStatement<Optional<User>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
if (linkedToUUID == null) {
statement.setNull(1, Types.VARCHAR);
} else {
statement.setString(1, linkedToUUID.toString());
}
}
@Override
public Optional<User> processResults(ResultSet set) throws SQLException {
if (set.next()) {
String username = set.getString(SecurityTable.USERNAME);
String linkedTo = set.getString(UsersTable.USER_NAME);
String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH);
int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL);
List<String> permissions = WebUser.getPermissionsForLevel(permissionLevel);
return Optional.of(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions));
}
return Optional.empty();
}
};
WHERE + SecurityTable.LINKED_TO + "=?" + LIMIT + "1";
return db -> db.queryOptional(sql, WebUserQueries::extractUser, linkedToUUID);
}
public static Query<List<User>> fetchAllUsers() {
String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME +
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID;
return new QueryAllStatement<List<User>>(sql) {
@Override
public List<User> processResults(ResultSet set) throws SQLException {
List<User> users = new ArrayList<>();
while (set.next()) {
String username = set.getString(SecurityTable.USERNAME);
String linkedTo = set.getString(UsersTable.USER_NAME);
UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null;
String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH);
int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL);
List<String> permissions = WebUser.getPermissionsForLevel(permissionLevel);
users.add(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions));
}
return users;
}
};
return db -> db.queryList(sql, WebUserQueries::extractUser);
}
public static Query<List<User>> matchUsers(String partOfUsername) {
String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME +
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID +
WHERE + "LOWER(" + SecurityTable.USERNAME + ") LIKE LOWER(?)";
return new QueryStatement<List<User>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setString(1, '%' + partOfUsername + '%');
}
@Override
public List<User> processResults(ResultSet set) throws SQLException {
List<User> users = new ArrayList<>();
while (set.next()) {
String username = set.getString(SecurityTable.USERNAME);
String linkedTo = set.getString(UsersTable.USER_NAME);
UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null;
String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH);
int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL);
List<String> permissions = WebUser.getPermissionsForLevel(permissionLevel);
users.add(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions));
}
return users;
}
};
return db -> db.queryList(sql, WebUserQueries::extractUser, '%' + partOfUsername + '%');
}
public static Query<Map<String, User>> fetchActiveCookies() {
@ -178,23 +84,8 @@ public class WebUserQueries {
LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID +
WHERE + CookieTable.EXPIRES + ">?";
return new QueryStatement<Map<String, User>>(sql) {
@Override
public void prepare(PreparedStatement statement) throws SQLException {
statement.setLong(1, System.currentTimeMillis());
}
@Override
public Map<String, User> processResults(ResultSet set) throws SQLException {
Map<String, User> usersByCookie = new HashMap<>();
while (set.next()) {
String cookie = set.getString(CookieTable.COOKIE);
User user = extractUser(set);
usersByCookie.put(cookie, user);
}
return usersByCookie;
}
};
return db -> db.queryMap(sql, (set, byCookie) -> byCookie.put(set.getString(CookieTable.COOKIE), extractUser(set)),
System.currentTimeMillis());
}
private static User extractUser(ResultSet set) throws SQLException {
@ -208,13 +99,7 @@ public class WebUserQueries {
}
public static Query<Map<String, Long>> getCookieExpiryTimes() {
return new QueryAllStatement<Map<String, Long>>(SELECT + CookieTable.COOKIE + ',' + CookieTable.EXPIRES + FROM + CookieTable.TABLE_NAME) {
@Override
public Map<String, Long> processResults(ResultSet set) throws SQLException {
HashMap<String, Long> expiryTimes = new HashMap<>();
while (set.next()) expiryTimes.put(set.getString(CookieTable.COOKIE), set.getLong(CookieTable.EXPIRES));
return expiryTimes;
}
};
String sql = SELECT + CookieTable.COOKIE + ',' + CookieTable.EXPIRES + FROM + CookieTable.TABLE_NAME;
return db -> db.queryMap(sql, (set, expiryTimes) -> expiryTimes.put(set.getString(CookieTable.COOKIE), set.getLong(CookieTable.EXPIRES)));
}
}

2
Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/GeolocationQueriesTest.java
View File

@ -206,7 +206,7 @@ public interface GeolocationQueriesTest extends DatabaseTestPreparer {
save(playerUUID, geoInfo);
}
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new));
Set<Integer> result = db().query(GeoInfoQueries.userIdsOfPlayersWithGeolocations(
Collections.singletonList(savedData.get(0).getGeolocation()))
);

6
Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java
View File

@ -71,7 +71,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer {
session.getExtraData().remove(JoinAddress.class);
db().executeTransaction(new StoreSessionTransaction(session));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new));
Set<Integer> result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses(List.of(JoinAddressTable.DEFAULT_VALUE_FOR_LOOKUP)));
assertEquals(expected, result);
@ -190,7 +190,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer {
default void joinAddressFilterUUIDsAreFetched() {
latestJoinAddressIsUpdatedUponSecondSession();
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new));
Set<Integer> result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses(
List.of(TestConstants.GET_PLAYER_HOSTNAME.get().toLowerCase()))
);
@ -201,7 +201,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer {
default void joinAddressFilterUUIDsAreFetchedWhenUnknown() {
joinAddressCanBeUnknown();
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new));
Set<Integer> result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses(
List.of(JoinAddressTable.DEFAULT_VALUE_FOR_LOOKUP))
);

2
Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/UserInfoQueriesTest.java
View File

@ -202,7 +202,7 @@ public interface UserInfoQueriesTest extends DatabaseTestPreparer {
}
}).get();
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(player2UUID)));
Set<Integer> expected = Set.of(db().query(BaseUserQueries.fetchUserId(player2UUID)).orElseThrow(AssertionError::new));
Set<Integer> result = db().query(BaseUserQueries.userIdsOfRegisteredBetween(2500L, 7500L));
assertEquals(expected, result);
}