use of org.structr.web.entity.html.Body in project structr by structr.
the class DeploymentTest method test19HtmlEntities.
@Test
public void test19HtmlEntities() {
// setup
try (final Tx tx = app.tx()) {
final Page page = Page.createNewPage(securityContext, "test19");
final Html html = createElement(page, page, "html");
final Head head = createElement(page, html, "head");
createElement(page, head, "title", "test19");
final Body body = createElement(page, html, "body");
final Div div1 = createElement(page, body, "div");
final Content content = createContent(page, div1, "<b>Test</b>");
content.setProperty(StructrApp.key(Content.class, "contentType"), "text/html");
tx.success();
} catch (FrameworkException fex) {
fail("Unexpected exception.");
}
// test
compare(calculateHash(), true, false);
}
use of org.structr.web.entity.html.Body in project structr by structr.
the class DeploymentTest method test32RoundtripWithEmptyContentElements.
@Test
public void test32RoundtripWithEmptyContentElements() {
// setup
try (final Tx tx = app.tx()) {
final Page page = Page.createNewPage(securityContext, "test32");
final Html html = createElement(page, page, "html");
final Head head = createElement(page, html, "head");
createElement(page, head, "title", "test32");
final Body body = createElement(page, html, "body");
final Div div1 = createElement(page, body, "div");
final Div div2 = createElement(page, div1, "div", " ");
final Ul ul = createElement(page, div1, "ul");
final Li li = createElement(page, ul, "li", " ");
tx.success();
} catch (FrameworkException fex) {
fail("Unexpected exception.");
}
compare(calculateHash(), true);
}
use of org.structr.web.entity.html.Body in project structr by structr.
the class DeploymentTest method test40TwoTemplatesWithSameNameInTwoPages.
@Test
public void test40TwoTemplatesWithSameNameInTwoPages() {
// setup
try (final Tx tx = app.tx()) {
// create first page
final Page page1 = Page.createNewPage(securityContext, "test40_1");
final Html html1 = createElement(page1, page1, "html");
final Head head1 = createElement(page1, html1, "head");
createElement(page1, head1, "title", "test40_1");
final Body body1 = createElement(page1, html1, "body");
final Div div1 = createElement(page1, body1, "div");
// create first template and give it a name
final Template template1 = createTemplate(page1, div1, "template source - öäüÖÄÜß'\"'`");
final PropertyMap template1Properties = new PropertyMap();
template1Properties.put(Template.name, "Test40Template");
template1.setProperties(template1.getSecurityContext(), template1Properties);
// create second page
final Page page2 = Page.createNewPage(securityContext, "test40_2");
final Html html2 = createElement(page2, page2, "html");
final Head head2 = createElement(page2, html2, "head");
createElement(page2, head2, "title", "test40_2");
final Body body2 = createElement(page2, html2, "body");
final Div div2 = createElement(page2, body2, "div");
// create second template and give it the same name as the first one
final Template template2 = createTemplate(page2, div2, "template source 2 - öäüÖÄÜß'\"'`");
final PropertyMap template2Properties = new PropertyMap();
template2Properties.put(Template.name, "Test40Template");
template2.setProperties(template2.getSecurityContext(), template2Properties);
tx.success();
} catch (FrameworkException fex) {
fail("Unexpected exception.");
}
// test
compare(calculateHash(), true);
}
use of org.structr.web.entity.html.Body in project structr by structr.
the class Importer method createChildNodes.
private DOMNode createChildNodes(final Node startNode, final DOMNode parent, final Page page, final boolean removeHashAttribute, final int depth) throws FrameworkException {
DOMNode rootElement = null;
Linkable res = null;
String instructions = null;
final List<Node> children = startNode.childNodes();
for (Node node : children) {
String tag = node.nodeName();
// clean tag, remove non-word characters except : and #
if (tag != null) {
tag = tag.replaceAll("[^a-zA-Z0-9#:.-_]+", "");
}
final StringBuilder classString = new StringBuilder();
final String type = CaseHelper.toUpperCamelCase(tag);
String comment = null;
String content = null;
String id = null;
boolean isNewTemplateOrComponent = false;
if (ignoreElementNames.contains(type)) {
continue;
}
if (node instanceof Element) {
final Element el = ((Element) node);
final Set<String> classes = el.classNames();
for (String cls : classes) {
classString.append(cls).append(" ");
}
id = el.id();
// do not download files when called from DeployCommand!
if (!isDeployment) {
String downloadAddressAttr = srcElements.contains(tag) ? "src" : hrefElements.contains(tag) ? "href" : null;
if (downloadAddressAttr != null && StringUtils.isNotBlank(node.attr(downloadAddressAttr))) {
String downloadAddress = node.attr(downloadAddressAttr);
res = downloadFile(downloadAddress, originalUrl);
} else {
res = null;
}
}
if (removeHashAttribute) {
// Remove data-structr-hash attribute
node.removeAttr("data-structr-hash");
}
}
// Data and comment nodes: Trim the text and put it into the "content" field without changes
if (type.equals("#comment")) {
comment = ((Comment) node).getData();
tag = "";
// Don't add content node for whitespace
if (StringUtils.isBlank(comment)) {
continue;
}
// store for later use
commentSource.append(comment).append("\n");
// check if comment contains instructions
if (commentHandler != null && commentHandler.containsInstructions(comment)) {
if (instructions != null) {
// unhandled instructions from previous iteration => empty content element
createEmptyContentNode(page, parent, commentHandler, instructions);
}
instructions = comment;
continue;
}
} else if (type.equals("#data")) {
tag = "";
content = ((DataNode) node).getWholeData();
// Don't add content node for whitespace
if (StringUtils.isBlank(content)) {
continue;
}
} else // Text-only nodes: Trim the text and put it into the "content" field
{
if (type.equals("#text")) {
tag = "";
if (isDeployment) {
content = trimTrailingNewline(((TextNode) node).getWholeText());
if (content == null || content.length() == 0) {
continue;
}
} else {
content = trimTrailingNewline(((TextNode) node).text());
if (StringUtils.isBlank(content)) {
continue;
}
}
}
}
org.structr.web.entity.dom.DOMNode newNode = null;
// create node
if (StringUtils.isBlank(tag)) {
if (page != null) {
// create comment or content node
if (!StringUtils.isBlank(comment)) {
final PropertyKey<String> contentTypeKey = StructrApp.key(Content.class, "contentType");
newNode = (DOMNode) page.createComment(comment);
newNode.setProperty(contentTypeKey, "text/html");
} else {
newNode = (Content) page.createTextNode(content);
}
}
} else if ("structr:template".equals(tag)) {
final String src = node.attr("src");
if (src != null) {
DOMNode template = null;
if (DeployCommand.isUuid(src)) {
template = (DOMNode) StructrApp.getInstance().nodeQuery(NodeInterface.class).and(GraphObject.id, src).getFirst();
if (template == null) {
System.out.println("##################################### template with UUID " + src + " not found, this is a known bug");
}
} else if (DeployCommand.endsWithUuid(src)) {
final String uuid = src.substring(src.length() - 32);
template = (DOMNode) StructrApp.getInstance().nodeQuery(NodeInterface.class).and(GraphObject.id, uuid).getFirst();
if (template == null) {
System.out.println("##################################### template with UUID " + uuid + " not found, this is a known bug");
}
} else {
template = Importer.findSharedComponentByName(src);
if (template == null) {
template = Importer.findTemplateByName(src);
if (template == null) {
template = createNewTemplateNode(parent, node.childNodes());
isNewTemplateOrComponent = true;
}
}
}
if (template != null) {
newNode = template;
if (template.isSharedComponent()) {
newNode = (DOMNode) template.cloneNode(false);
newNode.setSharedComponent(template);
newNode.setOwnerDocument(page);
} else if (page != null) {
newNode.setOwnerDocument(page);
}
} else {
logger.warn("Unable to find template or shared component {}, template ignored!", src);
}
} else {
logger.warn("Invalid template definition, missing src attribute!");
}
} else if ("structr:component".equals(tag)) {
final String src = node.attr("src");
if (src != null) {
DOMNode component = null;
if (DeployCommand.isUuid(src)) {
component = app.nodeQuery(DOMNode.class).and(GraphObject.id, src).getFirst();
} else {
component = Importer.findSharedComponentByName(src);
}
if (component == null) {
component = createSharedComponent(node);
}
isNewTemplateOrComponent = true;
if (component != null) {
newNode = (DOMNode) component.cloneNode(false);
newNode.setSharedComponent(component);
newNode.setOwnerDocument(page);
} else {
logger.warn("Unable to find shared component {} - ignored!", src);
}
} else {
logger.warn("Invalid component definition, missing src attribute!");
}
} else {
if (page != null) {
newNode = (org.structr.web.entity.dom.DOMElement) page.createElement(tag, true);
}
if (newNode == null) {
final PropertyKey<Boolean> hideOnDetailKey = StructrApp.key(DOMNode.class, "hideOnDetail");
final PropertyKey<Boolean> hideOnIndexKey = StructrApp.key(DOMNode.class, "hideOnIndex");
final PropertyKey<String> tagKey = StructrApp.key(DOMElement.class, "tag");
// experimental: create DOM element with literal tag
newNode = (DOMElement) app.create(DOMElement.class, new NodeAttribute(tagKey, node.nodeName()), new NodeAttribute(hideOnDetailKey, false), new NodeAttribute(hideOnIndexKey, false));
if (newNode != null && page != null) {
newNode.doAdopt(page);
}
/* disabled / replaced by implementation above
newNode = createNewHTMLTemplateNodeForUnsupportedTag(parent, node);
isNewTemplateOrComponent = true;
*/
}
}
if (newNode != null) {
// save root element for later use
if (rootElement == null && !(newNode instanceof org.structr.web.entity.dom.Comment)) {
rootElement = newNode;
}
// set linkable
if (res != null && newNode instanceof LinkSource) {
((LinkSource) newNode).setLinkable(res);
}
// container for bulk setProperties()
final PropertyMap newNodeProperties = new PropertyMap();
final Class newNodeType = newNode.getClass();
newNodeProperties.put(AbstractNode.visibleToPublicUsers, publicVisible);
newNodeProperties.put(AbstractNode.visibleToAuthenticatedUsers, authVisible);
// "id" attribute: Put it into the "_html_id" field
if (StringUtils.isNotBlank(id)) {
newNodeProperties.put(StructrApp.key(DOMElement.class, "_html_id"), id);
}
if (StringUtils.isNotBlank(classString.toString())) {
newNodeProperties.put(StructrApp.key(DOMElement.class, "_html_class"), StringUtils.trim(classString.toString()));
}
for (Attribute nodeAttr : node.attributes()) {
final String key = nodeAttr.getKey();
if (!key.equals("text")) {
// Don't add text attribute as _html_text because the text is already contained in the 'content' attribute
final String value = nodeAttr.getValue();
if (key.startsWith("data-")) {
if (key.startsWith(DATA_META_PREFIX)) {
// convert data-structr-meta-* attributes to local camel case properties on the node,
int l = DATA_META_PREFIX.length();
String upperCaseKey = WordUtils.capitalize(key.substring(l), new char[] { '-' }).replaceAll("-", "");
String camelCaseKey = key.substring(l, l + 1).concat(upperCaseKey.substring(1));
if (value != null) {
// store value using actual input converter
final PropertyKey actualKey = StructrApp.getConfiguration().getPropertyKeyForJSONName(newNodeType, camelCaseKey, false);
if (actualKey != null) {
final PropertyConverter converter = actualKey.inputConverter(securityContext);
if (converter != null) {
final Object convertedValue = converter.convert(value);
newNodeProperties.put(actualKey, convertedValue);
} else {
newNodeProperties.put(actualKey, value);
}
} else {
logger.warn("Unknown meta property key {}, ignoring.", camelCaseKey);
}
}
} else if (key.startsWith(DATA_STRUCTR_PREFIX)) {
// don't convert data-structr-* attributes as they are internal
final PropertyKey propertyKey = StructrApp.getConfiguration().getPropertyKeyForJSONName(newNodeType, key);
if (propertyKey != null) {
final PropertyConverter inputConverter = propertyKey.inputConverter(securityContext);
if (value != null && inputConverter != null) {
newNodeProperties.put(propertyKey, propertyKey.inputConverter(securityContext).convert(value));
} else {
newNodeProperties.put(propertyKey, value);
}
}
} else {
// store data-* attributes in node
final PropertyKey propertyKey = new StringProperty(key);
if (value != null) {
newNodeProperties.put(propertyKey, value);
}
}
} else {
boolean notBlank = StringUtils.isNotBlank(value);
boolean isAnchor = notBlank && value.startsWith("#");
boolean isLocal = notBlank && !value.startsWith("http");
boolean isActive = notBlank && value.contains("${");
boolean isStructrLib = notBlank && value.startsWith("/structr/js/");
if ("link".equals(tag) && "href".equals(key) && isLocal && !isActive && !isDeployment) {
newNodeProperties.put(new StringProperty(PropertyView.Html.concat(key)), "${link.path}?${link.version}");
} else if (("href".equals(key) || "src".equals(key)) && isLocal && !isActive && !isAnchor && !isStructrLib && !isDeployment) {
newNodeProperties.put(new StringProperty(PropertyView.Html.concat(key)), "${link.path}");
} else {
newNodeProperties.put(new StringProperty(PropertyView.Html.concat(key)), value);
}
}
}
}
// bulk set properties on new node
newNode.setProperties(securityContext, newNodeProperties);
if ("script".equals(tag)) {
final PropertyKey<String> typeKey = StructrApp.key(Input.class, "_html_type");
final String contentType = newNode.getProperty(typeKey);
if (contentType == null) {
// Set default type of script tag to "text/javascript" to ensure inline JS gets imported properly
newNode.setProperty(typeKey, "text/javascript");
} else if (contentType.equals("application/schema+json")) {
for (final Node scriptContentNode : node.childNodes()) {
final String source = scriptContentNode.toString();
// Import schema JSON
SchemaJsonImporter.importSchemaJson(source);
}
} else if (contentType.equals("application/x-structr-script")) {
for (final Node scriptContentNode : node.childNodes()) {
final String source = scriptContentNode.toString();
try {
Actions.execute(securityContext, null, source, null);
} catch (UnlicensedException ex) {
ex.log(logger);
}
}
continue;
} else if (contentType.equals("application/x-structr-javascript")) {
for (final Node scriptContentNode : node.childNodes()) {
final String source = scriptContentNode.toString();
try {
Actions.execute(securityContext, null, source, null);
} catch (UnlicensedException ex) {
ex.log(logger);
}
}
continue;
}
} else if ("style".equals(tag)) {
final PropertyKey<String> typeKey = StructrApp.key(Input.class, "_html_type");
final String contentType = newNode.getProperty(typeKey);
if ("text/css".equals(contentType)) {
// parse content of style elements and add referenced files to list of resources to be downloaded
for (final Node styleContentNode : node.childNodes()) {
final String source = styleContentNode.toString();
try {
// Import referenced resources
processCss(source, originalUrl);
} catch (IOException ex) {
logger.warn("Couldn't process CSS source", ex);
}
}
}
}
if (instructions != null) {
if (instructions.contains("@structr:content") && !(newNode instanceof Content)) {
// unhandled instructions from previous iteration => empty content element
createEmptyContentNode(page, parent, commentHandler, instructions);
} else {
// apply instructions to new DOM element
if (commentHandler != null) {
commentHandler.handleComment(page, newNode, instructions, true);
}
}
instructions = null;
}
// allow parent to be null to prevent direct child relationship
if (parent != null) {
// special handling for <head> elements
if (newNode instanceof Head && parent instanceof Body) {
final org.w3c.dom.Node html = parent.getParentNode();
html.insertBefore(newNode, parent);
} else {
parent.appendChild(newNode);
}
}
// Step down and process child nodes except for newly created templates
if (!isNewTemplateOrComponent) {
createChildNodes(node, newNode, page, removeHashAttribute, depth + 1);
}
}
}
// reset instructions when leaving a level
if (instructions != null) {
createEmptyContentNode(page, parent, commentHandler, instructions);
instructions = null;
}
return rootElement;
}
Aggregations