private Node processNodeSource(
final VirtualFile nodeFolder, final ProcessNodeSettings.Builder processNodeSettings) {
final VirtualFile nodeSource = this.exportReader.getNodeSource(nodeFolder);
final Node.Builder newNodeBuilder = Node.create();
try {
final XmlNodeParser parser = new XmlNodeParser();
parser.builder(newNodeBuilder);
parser.source(nodeSource.getCharSource());
parser.parse();
} catch (final Exception e) {
throw new XmlException(e, "Could not load source node [" + nodeSource.getUrl() + "]: ", e);
}
final Node newNode = newNodeBuilder.build();
final NodePath importNodePath =
NodeImportPathResolver.resolveNodeImportPath(nodeFolder, this.exportRoot, this.importRoot);
final boolean isNodeExisting = this.nodeService.getByPath(importNodePath) != null;
final Node importedNode = importNode(nodeFolder, processNodeSettings, newNode, importNodePath);
if (isNodeExisting) {
result.updated(importedNode.path());
} else {
result.added(importedNode.path());
}
return importedNode;
}
private void addBinary(
final VirtualFile nodeFile,
final BinaryAttachments.Builder builder,
final Property binaryRefProperty) {
final BinaryReference binaryReference = binaryRefProperty.getBinaryReference();
try {
final VirtualFile binary = exportReader.getBinarySource(nodeFile, binaryReference.toString());
builder.add(new BinaryAttachment(binaryReference, binary.getByteSource()));
result.addBinary(binary.getPath().getPath(), binaryReference);
} catch (Exception e) {
result.addError("Error processing binary, skip", e);
}
}
private void importFromManualOrder(final VirtualFile nodeFolder) {
final List<String> childNames;
try {
final List<String> relativeChildNames = processBinarySource(nodeFolder);
childNames = getChildrenAbsolutePaths(nodeFolder, relativeChildNames);
} catch (Exception e) {
result.addError("Not able to import nodes by manual order, using default ordering", e);
importFromDirectoryLayout(nodeFolder);
return;
}
long currentManualOrderValue = IMPORT_NODE_ORDER_START_VALUE;
for (final String childName : childNames) {
final VirtualFile child = nodeFolder.resolve(VirtualFilePaths.from(childName, "/"));
final ProcessNodeSettings.Builder processNodeSettings =
ProcessNodeSettings.create()
.insertManualStrategy(InsertManualStrategy.MANUAL)
.manualOrderValue(currentManualOrderValue);
if (child != null) {
processNodeFolder(child, processNodeSettings);
}
currentManualOrderValue -= IMPORT_NODE_ORDER_SPACE;
}
}
private void processNodeFolder(
final VirtualFile nodeFolder, final ProcessNodeSettings.Builder processNodeSettings) {
try {
final Node node = processNodeSource(nodeFolder, processNodeSettings);
try {
if (!node.getChildOrder().isManualOrder()) {
importFromDirectoryLayout(nodeFolder);
} else {
importFromManualOrder(nodeFolder);
}
} catch (Exception e) {
result.addError("Error when parsing children of " + node.path(), e);
}
} catch (Exception e) {
result.addError(
"Could not import node in folder ["
+ nodeFolder.getPath().getPath()
+ "]: "
+ e.getMessage(),
e);
}
}