forked from SteamWar/SteamWar
560 lines
24 KiB
Java
560 lines
24 KiB
Java
/*
|
|
* This file is a part of the SteamWar software.
|
|
*
|
|
* Copyright (C) 2020 SteamWar.de-Serverteam
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package de.steamwar.sql;
|
|
|
|
import de.steamwar.sql.internal.*;
|
|
import lombok.Getter;
|
|
|
|
import java.sql.Timestamp;
|
|
import java.time.Instant;
|
|
import java.util.*;
|
|
import java.util.function.Predicate;
|
|
|
|
public class SchematicNode {
|
|
|
|
static {
|
|
SchematicType.Normal.name(); // Ensure SchematicType is loaded.
|
|
new SqlTypeMapper<>(SchematicNode.class, null, (rs, identifier) -> { throw new SecurityException("SchematicNode cannot be used as type (recursive select)"); }, (st, index, value) -> st.setInt(index, value.nodeId));
|
|
}
|
|
|
|
private static final Map<Integer, Map<String, List<String>>> TAB_CACHE = new HashMap<>();
|
|
public static void clear() {
|
|
TAB_CACHE.clear();
|
|
}
|
|
|
|
private static final String nodeSelector = "SELECT NodeId, NodeOwner, NodeOwner AS EffectiveOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode ";
|
|
|
|
private static final Table<SchematicNode> table = new Table<>(SchematicNode.class);
|
|
private static final Statement create = table.insertFields(true, "NodeOwner", "NodeName", "ParentNode", "NodeItem", "NodeType");
|
|
private static final Statement update = table.update(Table.PRIMARY, "NodeName", "ParentNode", "NodeItem", "NodeType", "NodeRank", "ReplaceColor", "AllowReplay");
|
|
private static final Statement delete = table.delete(Table.PRIMARY);
|
|
|
|
private static final SelectStatement<SchematicNode> byId = new SelectStatement<>(table, nodeSelector + "WHERE NodeId = ?");
|
|
private static final SelectStatement<SchematicNode> byOwnerNameParent = new SelectStatement<>(table, nodeSelector + "WHERE NodeOwner = ? AND NodeName = ? AND ParentNode " + Statement.NULL_SAFE_EQUALS + "?");
|
|
private static final SelectStatement<SchematicNode> byParent = new SelectStatement<>(table, nodeSelector + "WHERE ParentNode" + Statement.NULL_SAFE_EQUALS + "? ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> dirsByParent = new SelectStatement<>(table, nodeSelector + "WHERE ParentNode" + Statement.NULL_SAFE_EQUALS + "? AND NodeType is NULL ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> byOwnerType = new SelectStatement<>(table, nodeSelector + "WHERE NodeOwner = ? AND NodeType = ? ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> byType = new SelectStatement<>(table, nodeSelector + "WHERE NodeType = ? ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> all = new SelectStatement<>(table, "SELECT * FROM EffectiveSchematicNode WHERE EffectiveOwner = ? ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> list = new SelectStatement<>(table, "SELECT SchematicNode.NodeId, NodeOwner, ? AS EffectiveOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId " + Statement.NULL_SAFE_EQUALS + "? AND NM.UserId = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, ? AS EffectiveOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode WHERE (? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?) ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> byParentName = new SelectStatement<>(table, "SELECT SchematicNode.NodeId, NodeOwner, ? AS EffectiveOwner, NodeName, NM.ParentId AS ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode INNER JOIN NodeMember NM on SchematicNode.NodeId = NM.NodeId WHERE NM.ParentId " + Statement.NULL_SAFE_EQUALS + "? AND NM.UserId = ? AND SchematicNode.NodeName = ? UNION ALL SELECT SchematicNode.NodeId, NodeOwner, ? AS EffectiveOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode WHERE ((? IS NULL AND ParentNode IS NULL AND NodeOwner = ?) OR (? IS NOT NULL AND ParentNode = ?)) AND NodeName = ?");
|
|
private static final SelectStatement<SchematicNode> schematicAccessibleForUser = new SelectStatement<>(table, "SELECT COUNT(DISTINCT NodeId) FROM EffectiveSchematicNode WHERE EffectiveOwner = ? AND NodeId = ?");
|
|
private static final SelectStatement<SchematicNode> accessibleByUserTypeInParent = new SelectStatement<>(table, "WITH RECURSIVE RSASN AS(WITH RECURSIVE RSAN AS (WITH RSANH AS (WITH RECURSIVE RSA AS (SELECT SN.NodeId, NM.ParentId FROM SchematicNode SN LEFT JOIN NodeMember NM on SN.NodeId = NM.NodeId WHERE NM.UserId = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN INNER JOIN RSA ON RSA.NodeId = SN.ParentNode) SELECT * FROM RSA UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?) SELECT * FROM RSANH UNION SELECT SN.NodeId, SN.ParentNode FROM RSANH JOIN SchematicNode SN ON SN.ParentNode = RSANH.NodeId) SELECT RSAN.NodeId, RSAN.ParentId FROM RSAN JOIN SchematicNode SN ON SN.NodeId = RSAN.NodeId WHERE NodeType = ? UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN JOIN RSASN ON SN.NodeId = RSASN.ParentId) SELECT SN.*, ? as EffectiveOwner, RSASN.ParentId AS ParentNode FROM RSASN JOIN SchematicNode SN ON SN.NodeId = RSASN.NodeId WHERE RSASN.ParentId" + Statement.NULL_SAFE_EQUALS + "? ORDER BY NodeName");
|
|
private static final SelectStatement<SchematicNode> accessibleByUserType = new SelectStatement<>(table, "WITH RECURSIVE Nodes AS (SELECT NodeId, ParentId as ParentNode FROM NodeMember WHERE UserId = ? UNION SELECT NodeId, ParentNode FROM SchematicNode WHERE NodeOwner = ?), RSN AS ( SELECT NodeId, ParentNode FROM Nodes UNION SELECT SN.NodeId, SN.ParentNode FROM SchematicNode SN, RSN WHERE SN.ParentNode = RSN.NodeId ) SELECT SN.*, ? AS EffectiveOwner FROM RSN INNER JOIN SchematicNode SN ON RSN.NodeId = SN.NodeId WHERE NodeType = ?");
|
|
private static final SelectStatement<SchematicNode> byIdAndUser = new SelectStatement<>(table, "SELECT NodeId, NodeOwner, ? AS EffectiveOwner, NodeName, ParentNode, LastUpdate, NodeItem, NodeType, NodeRank, ReplaceColor, AllowReplay FROM SchematicNode WHERE NodeId = ?");
|
|
private static final SelectStatement<SchematicNode> allParentsOfNode = new SelectStatement<>(table, "WITH RECURSIVE R AS (SELECT NodeId, ParentNode FROM EffectiveSchematicNode WHERE NodeId = ? AND EffectiveOwner = ? UNION SELECT E.NodeId, E.ParentNode FROM R, EffectiveSchematicNode E WHERE R.ParentNode = E.NodeId AND E.EffectiveOwner = ?) SELECT SN.NodeId, SN.NodeOwner, ? AS EffectiveOwner, SN.NodeName, R.ParentNode, SN.LastUpdate, SN.NodeItem, SN.NodeType, SN.NodeRank, SN.ReplaceColor, SN.AllowReplay FROM R INNER JOIN SchematicNode SN ON SN.NodeId = R.NodeId");
|
|
|
|
static {
|
|
NodeMember.init();
|
|
}
|
|
|
|
@Field(keys = {Table.PRIMARY}, autoincrement = true)
|
|
private final int nodeId;
|
|
@Field(keys = {"OwnerNameParent"})
|
|
private final int nodeOwner;
|
|
@Field(def = "0")
|
|
@Getter
|
|
private final int effectiveOwner;
|
|
@Field(keys = {"OwnerNameParent"})
|
|
private String nodeName;
|
|
@Field(keys = {"OwnerNameParent"}, nullable = true)
|
|
private Integer parentNode;
|
|
@Field(def = "CURRENT_TIMESTAMP")
|
|
private Timestamp lastUpdate;
|
|
@Field(def = "''")
|
|
private String nodeItem;
|
|
@Field(def = "'normal'", nullable = true)
|
|
private SchematicType nodeType;
|
|
@Field(def = "0")
|
|
private int nodeRank;
|
|
@Field(def = "1")
|
|
private boolean replaceColor;
|
|
@Field(def = "1")
|
|
private boolean allowReplay;
|
|
|
|
private String brCache;
|
|
|
|
public SchematicNode(
|
|
int nodeId,
|
|
int nodeOwner,
|
|
int effectiveOwner,
|
|
String nodeName,
|
|
Integer parentNode,
|
|
Timestamp lastUpdate,
|
|
String nodeItem,
|
|
SchematicType nodeType,
|
|
int nodeRank,
|
|
boolean replaceColor,
|
|
boolean allowReplay
|
|
) {
|
|
this.nodeId = nodeId;
|
|
this.nodeOwner = nodeOwner;
|
|
this.effectiveOwner = effectiveOwner;
|
|
this.nodeName = nodeName;
|
|
this.parentNode = parentNode;
|
|
this.nodeItem = nodeItem;
|
|
this.nodeType = nodeType;
|
|
this.lastUpdate = lastUpdate;
|
|
this.nodeRank = nodeRank;
|
|
this.replaceColor = replaceColor;
|
|
this.allowReplay = allowReplay;
|
|
}
|
|
|
|
public static List<SchematicNode> getAll(SteamwarUser user) {
|
|
return all.listSelect(user);
|
|
}
|
|
|
|
public static Map<Integer, List<SchematicNode>> getAllMap(SteamwarUser user) {
|
|
return map(getAll(user));
|
|
}
|
|
|
|
public static List<SchematicNode> list(SteamwarUser user, Integer schematicId) {
|
|
return list.listSelect(user, schematicId, user, user, schematicId, user, schematicId, schematicId);
|
|
}
|
|
|
|
public static SchematicNode byParentName(SteamwarUser user, Integer schematicId, String name) {
|
|
return byParentName.select(user, schematicId, user, name, user, schematicId, user, schematicId, schematicId, name);
|
|
}
|
|
|
|
public static List<SchematicNode> accessibleByUserType(SteamwarUser user, SchematicType type) {
|
|
return accessibleByUserType.listSelect(user, user, user, type);
|
|
}
|
|
|
|
public static Map<Integer, List<SchematicNode>> accessibleByUserTypeMap(SteamwarUser user, SchematicType type) {
|
|
return map(accessibleByUserType(user, type));
|
|
}
|
|
|
|
public static boolean schematicAccessibleForUser(SteamwarUser user, Integer schematicId) {
|
|
return schematicAccessibleForUser.select(user, schematicId) != null;
|
|
}
|
|
|
|
public static List<SchematicNode> accessibleByUserTypeParent(SteamwarUser user, SchematicType type, Integer parentId) {
|
|
return accessibleByUserTypeInParent.listSelect(user, user, type, user, parentId);
|
|
}
|
|
|
|
public static SchematicNode byIdAndUser(SteamwarUser user, Integer id) {
|
|
return byIdAndUser.select(user, id);
|
|
}
|
|
|
|
public static List<SchematicNode> parentsOfNode(SteamwarUser user, Integer id) {
|
|
return allParentsOfNode.listSelect(id, user, user, user);
|
|
}
|
|
|
|
private static Map<Integer, List<SchematicNode>> map(List<SchematicNode> in) {
|
|
Map<Integer, List<SchematicNode>> map = new HashMap<>();
|
|
for (SchematicNode effectiveSchematicNode : in) {
|
|
map.computeIfAbsent(effectiveSchematicNode.getOptionalParent().orElse(0), k -> new ArrayList<>()).add(effectiveSchematicNode);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
public static SchematicNode createSchematic(int owner, String name, Integer parent) {
|
|
return createSchematicNode(owner, name, parent, SchematicType.Normal.toDB(), "");
|
|
}
|
|
|
|
public static SchematicNode createSchematicDirectory(int owner, String name, Integer parent) {
|
|
return createSchematicNode(owner, name, parent, null, "");
|
|
}
|
|
|
|
public static SchematicNode createSchematicNode(int owner, String name, Integer parent, String type, String item) {
|
|
if (parent != null && parent == 0)
|
|
parent = null;
|
|
int nodeId = create.insertGetKey(owner, name, parent, item, type);
|
|
return getSchematicNode(nodeId);
|
|
}
|
|
|
|
public static SchematicNode getSchematicNode(int owner, String name, SchematicNode parent) {
|
|
return getSchematicNode(owner, name, parent.getId());
|
|
}
|
|
|
|
public static SchematicNode getSchematicNode(int owner, String name, Integer parent) {
|
|
return byOwnerNameParent.select(owner, name, parent);
|
|
}
|
|
|
|
public static List<SchematicNode> getSchematicNodeInNode(SchematicNode parent) {
|
|
return getSchematicNodeInNode(parent.getId());
|
|
}
|
|
|
|
public static List<SchematicNode> getSchematicNodeInNode(Integer parent) {
|
|
return byParent.listSelect(parent);
|
|
}
|
|
|
|
public static List<SchematicNode> getSchematicDirectoryInNode(Integer parent) {
|
|
return dirsByParent.listSelect(parent);
|
|
}
|
|
|
|
@Deprecated
|
|
public static SchematicNode getSchematicDirectory(String name, SchematicNode parent) {
|
|
return getSchematicNode(name, parent.getId());
|
|
}
|
|
|
|
@Deprecated
|
|
public static SchematicNode getSchematicDirectory(String name, Integer parent) {
|
|
return getSchematicNode(name, parent);
|
|
}
|
|
|
|
public static SchematicNode getSchematicNode(String name, Integer parent) {
|
|
return byParentName.select(name, parent);
|
|
}
|
|
|
|
public static SchematicNode getSchematicNode(int id) {
|
|
return byId.select(id);
|
|
}
|
|
|
|
public static List<SchematicNode> getAccessibleSchematicsOfTypeInParent(int owner, String schemType, Integer parent) {
|
|
return accessibleByUserTypeParent(SteamwarUser.get(owner), SchematicType.fromDB(schemType), parent);
|
|
}
|
|
|
|
public static List<SchematicNode> getAllAccessibleSchematicsOfType(int user, String schemType) {
|
|
return accessibleByUserType(SteamwarUser.get(user), SchematicType.fromDB(schemType));
|
|
}
|
|
|
|
public static List<SchematicNode> getAllSchematicsOfType(int owner, String schemType) {
|
|
return byOwnerType.listSelect(owner, schemType);
|
|
}
|
|
|
|
@Deprecated
|
|
public static List<SchematicNode> getAllSchematicsOfType(String schemType) {
|
|
return byType.listSelect(schemType);
|
|
}
|
|
|
|
public static List<SchematicNode> getAllSchematicsOfType(SchematicType schemType) {
|
|
return byType.listSelect(schemType);
|
|
}
|
|
|
|
public static List<SchematicNode> deepGet(Integer parent, Predicate<SchematicNode> filter) {
|
|
List<SchematicNode> finalList = new ArrayList<>();
|
|
List<SchematicNode> nodes = SchematicNode.getSchematicNodeInNode(parent);
|
|
nodes.forEach(node -> {
|
|
if (node.isDir()) {
|
|
finalList.addAll(deepGet(node.getId(), filter));
|
|
} else {
|
|
if (filter.test(node))
|
|
finalList.add(node);
|
|
}
|
|
});
|
|
return finalList;
|
|
}
|
|
|
|
@Deprecated
|
|
public static List<SchematicNode> getSchematicsAccessibleByUser(int user, Integer parent) {
|
|
return list(SteamwarUser.get(user), parent);
|
|
}
|
|
|
|
@Deprecated
|
|
public static List<SchematicNode> getAllSchematicsAccessibleByUser(int user) {
|
|
return getAll(SteamwarUser.get(user));
|
|
}
|
|
|
|
public static List<SchematicNode> getAllParentsOfNode(SchematicNode node) {
|
|
return getAllParentsOfNode(node.getId());
|
|
}
|
|
|
|
public static List<SchematicNode> getAllParentsOfNode(int node) {
|
|
return allParentsOfNode.listSelect(node);
|
|
}
|
|
|
|
public static SchematicNode getNodeFromPath(SteamwarUser user, String s) {
|
|
if (s.startsWith("/")) {
|
|
s = s.substring(1);
|
|
}
|
|
if (s.endsWith("/")) {
|
|
s = s.substring(0, s.length() - 1);
|
|
}
|
|
if (s.isEmpty()) {
|
|
return null;
|
|
}
|
|
if (s.contains("/")) {
|
|
String[] layers = s.split("/");
|
|
Optional<SchematicNode> currentNode = Optional.ofNullable(SchematicNode.byParentName(user, null, layers[0]));
|
|
for (int i = 1; i < layers.length; i++) {
|
|
int finalI = i;
|
|
Optional<SchematicNode> node = currentNode.map(effectiveSchematicNode -> SchematicNode.byParentName(user, effectiveSchematicNode.getId(), layers[finalI]));
|
|
if (!node.isPresent()) {
|
|
return null;
|
|
} else {
|
|
currentNode = node;
|
|
if (!currentNode.map(SchematicNode::isDir).orElse(false) && i != layers.length - 1) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
return currentNode.orElse(null);
|
|
} else {
|
|
return SchematicNode.byParentName(user, null, s);
|
|
}
|
|
}
|
|
|
|
public static List<SchematicNode> filterSchems(int user, Predicate<SchematicNode> filter) {
|
|
List<SchematicNode> finalList = new ArrayList<>();
|
|
List<SchematicNode> nodes = getSchematicsAccessibleByUser(user, null);
|
|
nodes.forEach(node -> {
|
|
if (node.isDir()) {
|
|
finalList.addAll(deepGet(node.getId(), filter));
|
|
} else {
|
|
if (filter.test(node))
|
|
finalList.add(node);
|
|
}
|
|
});
|
|
return finalList;
|
|
}
|
|
|
|
public int getId() {
|
|
return nodeId;
|
|
}
|
|
|
|
public int getOwner() {
|
|
return nodeOwner;
|
|
}
|
|
|
|
public String getName() {
|
|
return nodeName;
|
|
}
|
|
|
|
public void setName(String name) {
|
|
this.nodeName = name;
|
|
updateDB();
|
|
}
|
|
|
|
public Integer getParent() {
|
|
return parentNode;
|
|
}
|
|
|
|
public Optional<Integer> getOptionalParent() {
|
|
return Optional.ofNullable(parentNode);
|
|
}
|
|
|
|
public void setParent(Integer parent) {
|
|
this.parentNode = parent;
|
|
updateDB();
|
|
}
|
|
|
|
public String getItem() {
|
|
if (nodeItem.isEmpty()) {
|
|
return isDir() ? "CHEST" : "CAULDRON_ITEM";
|
|
}
|
|
return nodeItem;
|
|
}
|
|
|
|
public void setItem(String item) {
|
|
this.nodeItem = item;
|
|
updateDB();
|
|
}
|
|
|
|
@Deprecated
|
|
public String getType() {
|
|
return nodeType.name();
|
|
}
|
|
|
|
@Deprecated
|
|
public void setType(String type) {
|
|
if(isDir())
|
|
throw new SecurityException("Node is Directory");
|
|
this.nodeType = SchematicType.fromDB(type);
|
|
updateDB();
|
|
}
|
|
|
|
public boolean isDir() {
|
|
return nodeType == null;
|
|
}
|
|
|
|
@Deprecated
|
|
public boolean getSchemFormat() {
|
|
if(isDir())
|
|
throw new SecurityException("Node is Directory");
|
|
return NodeData.get(this).getNodeFormat();
|
|
}
|
|
|
|
public int getRank() {
|
|
if(isDir())
|
|
throw new SecurityException("Node is Directory");
|
|
return nodeRank;
|
|
}
|
|
|
|
@Deprecated
|
|
public int getRankUnsafe() {
|
|
return nodeRank;
|
|
}
|
|
|
|
public void setRank(int rank) {
|
|
if(isDir())
|
|
throw new SecurityException("Node is Directory");
|
|
this.nodeRank = rank;
|
|
}
|
|
|
|
public SchematicType getSchemtype() {
|
|
if(isDir())
|
|
throw new SecurityException("Is Directory");
|
|
return nodeType;
|
|
}
|
|
|
|
public void setSchemtype(SchematicType type) {
|
|
if(isDir())
|
|
throw new SecurityException("Is Directory");
|
|
this.nodeType = type;
|
|
updateDB();
|
|
}
|
|
|
|
public boolean replaceColor() {
|
|
return replaceColor;
|
|
}
|
|
|
|
public void setReplaceColor(boolean replaceColor) {
|
|
if(isDir())
|
|
throw new SecurityException("Is Directory");
|
|
this.replaceColor = replaceColor;
|
|
updateDB();
|
|
}
|
|
|
|
public boolean allowReplay() {
|
|
return allowReplay;
|
|
}
|
|
|
|
public void setAllowReplay(boolean allowReplay) {
|
|
if(isDir())
|
|
throw new SecurityException("Is Directory");
|
|
this.allowReplay = allowReplay;
|
|
updateDB();
|
|
}
|
|
|
|
public SchematicNode getParentNode() {
|
|
if(parentNode == null) return null;
|
|
return SchematicNode.getSchematicNode(parentNode);
|
|
}
|
|
|
|
public int getElo(int season) {
|
|
return SchemElo.getElo(this, season);
|
|
}
|
|
|
|
public boolean accessibleByUser(int user) {
|
|
return NodeMember.getNodeMember(nodeId, user) != null;
|
|
}
|
|
|
|
public Set<NodeMember> getMembers() {
|
|
return NodeMember.getNodeMembers(nodeId);
|
|
}
|
|
|
|
public Timestamp getLastUpdate() {
|
|
return lastUpdate;
|
|
}
|
|
|
|
private void updateDB() {
|
|
this.lastUpdate = Timestamp.from(Instant.now());
|
|
update.update(nodeName, parentNode, nodeItem, nodeType, nodeRank, replaceColor, allowReplay, nodeId);
|
|
TAB_CACHE.clear();
|
|
}
|
|
|
|
public void delete() {
|
|
delete.update(nodeId);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return nodeId;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof SchematicNode))
|
|
return false;
|
|
|
|
return ((SchematicNode) obj).getId() == nodeId;
|
|
}
|
|
|
|
public String generateBreadcrumbs(SteamwarUser user) {
|
|
return byIdAndUser(user, nodeId).generateBreadcrumbs();
|
|
}
|
|
|
|
public String generateBreadcrumbs(String split, SteamwarUser user) {
|
|
return byIdAndUser(user, nodeId).generateBreadcrumbs(split);
|
|
}
|
|
|
|
public String generateBreadcrumbs() {
|
|
if(brCache == null) {
|
|
brCache = generateBreadcrumbs("/");
|
|
}
|
|
return brCache;
|
|
}
|
|
|
|
public String generateBreadcrumbs(String split) {
|
|
StringBuilder builder = new StringBuilder(getName());
|
|
Optional<SchematicNode> currentNode = Optional.of(this);
|
|
if(currentNode.map(SchematicNode::isDir).orElse(false)) {
|
|
builder.append(split);
|
|
}
|
|
while (currentNode.isPresent()) {
|
|
currentNode = currentNode.flatMap(schematicNode -> Optional.ofNullable(NodeMember.getNodeMember(schematicNode.getId(), effectiveOwner)).map(NodeMember::getParent).orElse(schematicNode.getOptionalParent())).map(SchematicNode::getSchematicNode);
|
|
currentNode.ifPresent(node -> builder.insert(0, split).insert(0, node.getName()));
|
|
}
|
|
return builder.toString();
|
|
}
|
|
|
|
private static final List<String> FORBIDDEN_NAMES = Collections.unmodifiableList(Arrays.asList("public"));
|
|
public static boolean invalidSchemName(String[] layers) {
|
|
for (String layer : layers) {
|
|
if (layer.isEmpty()) {
|
|
return true;
|
|
}
|
|
if (layer.contains("/") ||
|
|
layer.contains("\\") ||
|
|
layer.contains("<") ||
|
|
layer.contains(">") ||
|
|
layer.contains("^") ||
|
|
layer.contains("°") ||
|
|
layer.contains("'") ||
|
|
layer.contains("\"") ||
|
|
layer.contains(" ")) {
|
|
return true;
|
|
}
|
|
if(FORBIDDEN_NAMES.contains(layer.toLowerCase())) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static List<String> getNodeTabcomplete(SteamwarUser user, String s) {
|
|
boolean sws = s.startsWith("/");
|
|
if (sws) {
|
|
s = s.substring(1);
|
|
}
|
|
int index = s.lastIndexOf("/");
|
|
String cacheKey = index == -1 ? "" : s.substring(0, index);
|
|
if(TAB_CACHE.containsKey(user.getId()) && TAB_CACHE.get(user.getId()).containsKey(cacheKey)) {
|
|
return new ArrayList<>(TAB_CACHE.get(user.getId()).get(cacheKey));
|
|
}
|
|
List<String> list = new ArrayList<>();
|
|
if (s.contains("/")) {
|
|
String preTab = s.substring(0, s.lastIndexOf("/") + 1);
|
|
SchematicNode pa = SchematicNode.getNodeFromPath(user, preTab);
|
|
if (pa == null) return new ArrayList<>();
|
|
List<SchematicNode> nodes = SchematicNode.list(user, pa.getId());
|
|
String br = pa.generateBreadcrumbs();
|
|
nodes.forEach(node -> list.add((sws ? "/" : "") + br + node.getName() + (node.isDir() ? "/" : "")));
|
|
} else {
|
|
List<SchematicNode> nodes = SchematicNode.list(user, null);
|
|
nodes.forEach(node -> list.add((sws ? "/" : "") + node.getName() + (node.isDir() ? "/" : "")));
|
|
}
|
|
list.remove("//copy");
|
|
TAB_CACHE.computeIfAbsent(user.getId(), integer -> new HashMap<>()).putIfAbsent(cacheKey, list);
|
|
return list;
|
|
}
|
|
}
|