Newer
Older
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package it.inaf.oats.vospace.datamodel;
import java.security.Principal;
import java.util.ArrayList;
import java.util.List;
import net.ivoa.xml.vospace.v2.ContainerNode;
import net.ivoa.xml.vospace.v2.DataNode;
import net.ivoa.xml.vospace.v2.Node;
import net.ivoa.xml.vospace.v2.StructuredDataNode;
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class NodeUtils {
/**
* Slash is a special character in defining REST endpoints and trying to
* define a PathVariable containing slashes doesn't work, so the endpoint
* has been defined using "/nodes/**" instead of "/nodes/{path}" and the
* path is extracted manually parsing the request URL.
*/
public static String getPathFromRequestURLString(String requestUrlString ) {
String[] split = requestUrlString.split("/nodes/");
String path = "/";
if (split.length == 2) {
path += split[1];
}
return path;
}
// This method assumes that URL is in the format /node1/node2/...
// multiple slashes as a single separator are allowed
// But the output has only single slash separators
public static String getParentPath(String path) {
String[] parsedPath = path.split("[/]+");
if (parsedPath.length < 2 || !parsedPath[0].isEmpty()) {
throw new IllegalArgumentException();
}
StringBuilder sb = new StringBuilder();
sb.append("/");
for (int i = 1; i < parsedPath.length - 1; i++) {
sb.append(parsedPath[i]);
if (i < parsedPath.length - 2) {
sb.append("/");
}
}
return sb.toString();
}
public static List<String> subPathComponents(String path) {
List resultList = new ArrayList<String>();
String[] pathComponents = path.split("[/]+");
if (pathComponents.length == 0) {
// Manage root node
resultList.add("/");
} else {
// Manage all precursors in full path
String parentPath="/";
for (int i = 1; i < pathComponents.length; i++) {
parentPath = parentPath + pathComponents[i] + "/";
// "I'm managing path = " + parentPath.substring(0, parentPath.length()-1));
resultList.add(parentPath.substring(0, parentPath.length()-1));
}
}
return resultList;
}
public static boolean checkIfWritable(Node myNode, String userName, List<String> userGroups) {
return checkAccessPropery(myNode, userName, userGroups, NodeProperties.GROUP_WRITE_URI);
}
public static boolean checkIfRedeable(Node myNode, String userName, List<String> userGroups) {
return checkAccessPropery(myNode, userName, userGroups, NodeProperties.GROUP_READ_URI);
}
public static boolean checkAccessPropery(Node myNode, String userName,
List<String> userGroups, String accessPropertyName) {
// First check if parent node creator is == userid
List<String> nodeOwner
= NodeProperties.getNodePropertiesListByURI(myNode, NodeProperties.CREATOR_URI);
if (nodeOwner == null
|| nodeOwner.isEmpty()
|| !nodeOwner.get(0).equals(userName)) {
// Node owner check has failed: let's check if user can write
// due to group privileges
// If the user doesn't belong to any groups throw exception
if (userGroups == null || userGroups.isEmpty()) {
return false;
}
List<String> groupAccessPropValues
= NodeProperties.getNodePropertiesListByURI(myNode,
accessPropertyName);
// If groupwrite property is absent in Parent Node throw exception
if (groupAccessPropValues == null
|| groupAccessPropValues.isEmpty()) {
return false;
}
List<String> nodeGroups
= NodeProperties.parsePropertyStringToList(groupAccessPropValues.get(0));
if (nodeGroups.isEmpty()
|| !nodeGroups.stream()
.anyMatch((i) -> userGroups.contains(i))) {
return false;
}
}
return true;
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
}
public static String getDbNodeType(Node node) {
if (node instanceof ContainerNode) {
return "container";
} else if (node instanceof DataNode) {
return "data";
}
throw new UnsupportedOperationException("Unable to retrieve database node type for class " + node.getClass().getCanonicalName());
}
public static String getNodeName(String path) {
String[] parsedPath = path.split("/");
return parsedPath[parsedPath.length - 1];
}
public static String getNodeName(Node myNode) {
String uri = myNode.getUri();
return getNodeName(uri);
}
public static boolean getIsBusy(Node myNode) {
if (myNode instanceof DataNode) {
DataNode dataNode = (DataNode) myNode;
return dataNode.isBusy();
}
return false;
}
public static Node getTypedNode(String type) {
Node node;
switch (type) {
case "container":
node = new ContainerNode();
break;
case "data":
node = new DataNode();
break;
case "structured":
node = new StructuredDataNode();
break;
default:
throw new UnsupportedOperationException("Node type " + type + " not supported yet");
}
return node;