@Override
public void deleteData(final int offset, final int count) throws DOMException {
checkWriteAccess();
// finally, set content to concatenated left and right parts
try {
Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
String text = getProperty(content);
String leftPart = text.substring(0, offset);
String rightPart = text.substring(offset + count);
setProperty(content, leftPart.concat(rightPart));
return null;
}
});
} catch (FrameworkException fex) {
throw new DOMException(DOMException.INVALID_STATE_ERR, fex.toString());
}
}
private void setPermission(
final AbstractNode obj,
final Principal principal,
final String action,
final String permission,
final boolean rec)
throws FrameworkException {
Services.command(getWebSocket().getSecurityContext(), TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
switch (action) {
case "grant":
principal.grant(Permission.valueOf(permission), obj);
break;
case "revoke":
principal.revoke(Permission.valueOf(permission), obj);
break;
}
return null;
};
});
}
@Override
public void appendData(final String data) throws DOMException {
checkWriteAccess();
// set content to concatenated text and data
try {
Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
String text = getProperty(content);
setProperty(content, text.concat(data));
return null;
}
});
} catch (FrameworkException fex) {
throw new DOMException(DOMException.INVALID_STATE_ERR, fex.toString());
}
}
private void setOwner(final AbstractNode node, final AbstractNode user)
throws FrameworkException {
// Create outer transaction to bundle inner transactions
Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
DeleteRelationshipCommand delRel =
Services.command(securityContext, DeleteRelationshipCommand.class);
// Remove any existing OWNS relationships
for (AbstractRelationship s :
node.getRelationships(RelType.OWNS, Direction.INCOMING)) {
delRel.execute(s);
}
// Create new relationship to user and grant permissions to user or group
Services.command(securityContext, CreateRelationshipCommand.class)
.execute(user, node, RelType.OWNS);
return null;
}
});
}
@Override
protected void setUp() throws Exception {
init();
securityContext = SecurityContext.getSuperUserInstance();
createNodeCommand = Services.command(securityContext, CreateNodeCommand.class);
createRelationshipCommand = Services.command(securityContext, CreateRelationshipCommand.class);
deleteNodeCommand = Services.command(securityContext, DeleteNodeCommand.class);
transactionCommand = Services.command(securityContext, TransactionCommand.class);
graphDbCommand = Services.command(securityContext, GraphDatabaseCommand.class);
findNodeCommand = Services.command(securityContext, FindNodeCommand.class);
}
private void setOwner(final List<AbstractNode> nodeList, final AbstractNode user)
throws FrameworkException {
// Create outer transaction to bundle inner transactions
Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
for (AbstractNode node : nodeList) {
setOwner(node, user);
}
return null;
}
});
}
@Override
public boolean isValid(
GraphObject object, PropertyKey<String> key, String value, ErrorBuffer errorBuffer) {
if (key == null) {
return false;
}
if (StringUtils.isBlank(value)) {
errorBuffer.add(object.getType(), new EmptyPropertyToken(key));
return false;
}
// FIXME: search should be case-sensitive!
List<SearchAttribute> attrs = new LinkedList<SearchAttribute>();
attrs.add(Search.andExactName(value));
attrs.add(Search.andType(type));
// just check for existance
try {
Result nodes = Services.command(securityContext, SearchNodeCommand.class).execute(attrs);
if (nodes != null && !nodes.isEmpty()) {
return true;
} else {
errorBuffer.add(object.getType(), new PropertyNotFoundToken(key, value));
return false;
}
} catch (FrameworkException fex) {
// handle error
}
return false;
}
@Override
public void insertData(final int offset, final String data) throws DOMException {
checkWriteAccess();
try {
Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
String text = getProperty(content);
String leftPart = text.substring(0, offset);
String rightPart = text.substring(offset);
StringBuilder buf = new StringBuilder(text.length() + data.length() + 1);
buf.append(leftPart);
buf.append(data);
buf.append(rightPart);
// finally, set content to concatenated left, data and right parts
setProperty(content, buf.toString());
return null;
}
});
} catch (FrameworkException fex) {
throw new DOMException(DOMException.INVALID_STATE_ERR, fex.toString());
}
}
@Override
public Text splitText(int offset) throws DOMException {
checkWriteAccess();
String text = getProperty(content);
if (text != null) {
int len = text.length();
if (offset < 0 || offset > len) {
throw new DOMException(DOMException.INDEX_SIZE_ERR, INDEX_SIZE_ERR_MESSAGE);
} else {
final String firstPart = text.substring(0, offset);
final String secondPart = text.substring(offset);
final Document document = getOwnerDocument();
final Node parent = getParentNode();
if (document != null && parent != null) {
try {
return Services.command(securityContext, TransactionCommand.class)
.execute(
new StructrTransaction<Text>() {
@Override
public Text execute() throws FrameworkException {
// first part goes into existing text element
setProperty(content, firstPart);
// second part goes into new text element
Text newNode = document.createTextNode(secondPart);
// make new node a child of old parent
parent.appendChild(newNode);
return newNode;
}
});
} catch (FrameworkException fex) {
throw new DOMException(DOMException.INVALID_STATE_ERR, fex.toString());
}
} else {
throw new DOMException(DOMException.INVALID_STATE_ERR, CANNOT_SPLIT_TEXT_WITHOUT_PARENT);
}
}
}
throw new DOMException(DOMException.INDEX_SIZE_ERR, INDEX_SIZE_ERR_MESSAGE);
}
@Override
public Object execute(Object... parameters) throws FrameworkException {
if (parameters == null || parameters.length < 2) {
throw new UnsupportedArgumentError("Wrong number of arguments");
}
Long csvNodeId = null;
AbstractNode sourceNode = null;
Class targetClass = null;
CsvFile csvFileNode = null;
String filePath = null;
Principal user = null;
for (Object o : parameters) {
if (o instanceof CsvFile) {
csvFileNode = (CsvFile) o;
filePath = Services.getFilesPath() + "/" + csvFileNode.getRelativeFilePath();
}
if (o instanceof Long) {
csvNodeId = (Long) o;
sourceNode =
(AbstractNode)
Services.command(securityContext, FindNodeCommand.class).execute(csvNodeId);
if (sourceNode instanceof CsvFile) {
csvFileNode = (CsvFile) sourceNode;
filePath = Services.getFilesPath() + "/" + csvFileNode.getRelativeFilePath();
}
}
if (o instanceof Class) {
targetClass = (Class) o;
}
if (o instanceof Principal) {
user = (Principal) o;
}
}
try {
// TODO: Implement auto-detection for field separator and quote characters
CSVReader reader = new CSVReader(new FileReader(filePath), '|', '\"');
// Read first line, these should be the column keys
String[] keys = reader.readNext();
// Get the fields of the target node
Field[] fields = targetClass.getFields();
// The field index stores the field name of a column
Map<Integer, String> fieldIndex = new HashMap<Integer, String>();
// Instantiate object
AbstractNode o = (AbstractNode) targetClass.newInstance();
int col = 0;
// Match with fields
for (String key : keys) {
for (Field f : fields) {
String fieldName = (String) f.get(o);
if (fieldName.toUpperCase().equals(key.toUpperCase())) {
fieldIndex.put(col, fieldName);
}
}
col++;
}
for (Entry<Integer, String> entry : fieldIndex.entrySet()) {
Integer i = entry.getKey();
String v = entry.getValue();
System.out.println("v: " + v + ", i: " + i);
}
// List<String[]> lines = reader.readAll();
final Principal userCopy = user;
final AbstractNode sourceNodeCopy = csvFileNode;
final Command transactionCommand =
Services.command(securityContext, TransactionCommand.class);
final Command createNode = Services.command(securityContext, CreateNodeCommand.class);
final Command createRel = Services.command(securityContext, CreateRelationshipCommand.class);
final NodeList<AbstractNode> nodeListNode =
(NodeList<AbstractNode>)
transactionCommand.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
// If the node list node doesn't exist, create one
NodeList<AbstractNode> result =
(NodeList)
createNode.execute(
userCopy,
new NodeAttribute(
AbstractNode.Key.type.name(), NodeList.class.getSimpleName()),
new NodeAttribute(
AbstractNode.Key.name.name(),
sourceNodeCopy.getName() + " List"));
createRel.execute(sourceNodeCopy, result, RelType.CONTAINS);
return result;
}
});
final List<List<NodeAttribute>> creationList = new LinkedList<List<NodeAttribute>>();
String targetClassName = targetClass.getSimpleName();
String[] line = null;
do {
// read line, one at a time
try {
line = reader.readNext();
} catch (Throwable t) {
}
if (line != null) {
// create a new list for each item
List<NodeAttribute> nodeAttributes = new LinkedList<NodeAttribute>();
nodeAttributes.add(new NodeAttribute(AbstractNode.Key.type.name(), targetClassName));
for (int i = 0; i < col; i++) {
String csvValue = line[i];
String key = fieldIndex.get(i);
nodeAttributes.add(new NodeAttribute(key, csvValue));
}
// add node attributes to creation list
creationList.add(nodeAttributes);
}
} while (line != null);
reader.close();
// everything in one transaction
transactionCommand.execute(
new StructrTransaction() {
@Override
public Object execute() throws FrameworkException {
List<AbstractNode> nodesToAdd = new LinkedList<AbstractNode>();
for (List<NodeAttribute> attrList : creationList) {
nodesToAdd.add((AbstractNode) createNode.execute(attrList, false)); // don't index
}
// use bulk add
nodeListNode.addAll(nodesToAdd);
return (null);
}
});
/*
* final List<NodeAttribute> attrList = new LinkedList<NodeAttribute>();
*
* NodeAttribute typeAttr = new NodeAttribute(AbstractNode.Key.type.name(), targetClass.getSimpleName());
* attrList.add(typeAttr);
*
* String[] line = null;
*
* do
* {
* try
* {
* line = reader.readNext();
*
* } catch(Throwable t)
* {
* line = null;
* }
*
* if(line != null)
* {
* for(int i = 0; i < col; i++)
* {
*
* String csvValue = line[i];
* String key = fieldIndex.get(i);
*
* System.out.println("Creating attribute " + key + " = '" + csvValue + "'..");
*
* NodeAttribute attr = new NodeAttribute(key, csvValue);
* attrList.add(attr);
*
* logger.log(Level.FINEST, "Created node attribute {0}={1}", new Object[]
* {
* attr.getKey(), attr.getValue()
* });
* }
*
* AbstractNode newNode = (AbstractNode)transactionCommand.execute(new StructrTransaction()
* {
* @Override
* public Object execute() throws Throwable
* {
* Command createNode = Services.command(securityContext, CreateNodeCommand.class);
*
* // Create new node
* AbstractNode newNode = (AbstractNode)createNode.execute(userCopy, attrList);
* transactionCommand.setExitCode(createNode.getExitCode());
* transactionCommand.setErrorMessage(createNode.getErrorMessage());
* return newNode;
* }
* });
*
* nodeListNode.add(newNode);
* logger.log(Level.INFO, "Node {0} added to node list", newNode.getId());
* }
*
* } while(line != null);
*/
return nodeListNode;
} catch (Throwable t) {
// TODO: use logger
t.printStackTrace(System.out);
}
return null;
}
@Override
public Object execute(Object... parameters) throws FrameworkException {
Command findRel = Services.command(securityContext, FindRelationshipCommand.class);
for (Enum indexName : (RelationshipIndex[]) arguments.get("relationshipIndices")) {
indices.put(indexName.name(), (Index<Relationship>) arguments.get(indexName.name()));
}
long id = 0;
AbstractRelationship rel = null;
String key = null;
switch (parameters.length) {
case 1:
// index all properties of this relationship
if (parameters[0] instanceof Long) {
id = ((Long) parameters[0]).longValue();
rel = (AbstractRelationship) findRel.execute(id);
indexRelationship(rel);
} else if (parameters[0] instanceof String) {
id = Long.parseLong((String) parameters[0]);
rel = (AbstractRelationship) findRel.execute(id);
indexRelationship(rel);
} else if (parameters[0] instanceof AbstractRelationship) {
rel = (AbstractRelationship) parameters[0];
indexRelationship(rel);
} else if (parameters[0] instanceof List) {
indexRelationships((List<AbstractRelationship>) parameters[0]);
}
break;
case 2:
// index a certain property
if (parameters[0] instanceof Long) {
id = ((Long) parameters[0]).longValue();
rel = (AbstractRelationship) findRel.execute(id);
} else if (parameters[0] instanceof String) {
id = Long.parseLong((String) parameters[0]);
rel = (AbstractRelationship) findRel.execute(id);
} else if (parameters[0] instanceof AbstractRelationship) {
rel = (AbstractRelationship) parameters[0];
// id = node.getId();
}
if (parameters[1] instanceof String) {
key = (String) parameters[1];
}
if (rel == null) {
logger.log(
Level.SEVERE,
"Wrong type of parameters for the index relationship command: {0}",
parameters);
}
indexProperty(rel, key);
break;
default:
logger.log(
Level.SEVERE,
"Wrong number of parameters for the index relationship command: {0}",
parameters);
return null;
}
return null;
}
