@Override public void render(final RenderingContext renderingCtx, Map<String, Object> contextObjects) throws RenderException { Node content = renderingCtx.getCurrentContent(); // FIXME for the time being we only render pages and areas but not components try { final Site site = getSite(content); RenderableDefinition renderableDefinition = renderingCtx.getRenderableDefinition(); // merge in case of a page if (renderableDefinition instanceof STKPage) { renderableDefinition = (RenderableDefinition) BeanMergerUtil.merge(renderableDefinition, site.getTemplates().getPrototype(), DefaultSTKTemplateConfiguration.getInstance()); } // FIXME we should not push() if the definition is not merged renderingCtx.push(content, renderableDefinition); try { super.render(renderingCtx, contextObjects); } finally { renderingCtx.pop(); } } catch (Exception e) { throw new RenderException(e); } }
@Override public void handleException(RenderException renderException, RenderingContext renderingContext) { try { final String path = renderingContext.getCurrentContent().getPath(); final PrintWriter printWriter = getPrintWriterFor(renderingContext.getAppendable()); final String id = renderingContext.getRenderableDefinition().getId(); final AggregationState aggregationState = aggregationStateProvider.get(); final String msg = String.format("Error while rendering [%s] with template [%s] for URI [%s]:\n%s", path, id, formatURI(aggregationState), ExceptionUtils.getMessage(renderException)); this.processException(renderException, printWriter, msg); } catch (RepositoryException e) { throw new RuntimeException("Can't log template exception.", e); } catch (IOException e) { throw new RuntimeException("Can't log template exception.", e); } }
@Override public void render(Node content, RenderableDefinition definition, Map<String, Object> contextObjects, OutputProvider out) throws RenderException { RenderableDefinition variation = variationResolver.resolveVariation(definition); definition = variation != null ? variation : definition; final Renderer renderer = getRendererFor(definition); final RenderingContext renderingContext = getRenderingContext(); renderingContext.push(content, definition, out); try { Collection<RenderingListenerReturnCode> listenerResults = renderingContext.before(content, definition, contextObjects, out); if (listenerResults.contains(RenderingListenerReturnCode.SKIP) || listenerResults.contains(RenderingListenerReturnCode.STOP)) { return; } renderer.render(renderingContext, contextObjects); } catch (RenderException e) { renderingContext.handleException(e); } finally { renderingContext.after(content, definition, contextObjects, out); renderingContext.pop(); } }
@Test public void testRenderWithModelAttributePrefixBeingNullAndRenderingSkipped() throws Exception { // GIVEN RenderableDefinition definition = mock(RenderableDefinition.class); when(definition.getModelClass()).thenReturn(SkipRenderingDummyModel.class); when(ctx.getCurrentContent()).thenReturn(content); when(ctx.getRenderableDefinition()).thenReturn(definition); AbstractRenderer renderer = new DummyRenderer() { @Override protected String resolveTemplateScript(Node content, RenderableDefinition definition, RenderingModel<?> model, String actionResult) { throw new RuntimeException("Should have exited method before this call!"); } }; // WHEN renderer.render(ctx, null); // THEN - didn't get a RuntimeException on call above so execution stopped before calling determineTemplatePath... }
@Override public void render(RenderingContext ctx, Map<String, Object> contextObjects) throws RenderException { String logMessage = ""; Node content = ctx.getCurrentContent(); if (session.nodeExists(referencedPath)) { referencedResource = session.getNode(referencedPath); engine.render(referencedResource, ctx.getOutputProvider()); } else { logMessage = "The referenced resource '" + referencedPath + "' does not exist."; AppendableWriter out = ctx.getAppendable(); out.append(htmlCommentLogMessage(logMessage));
@Test(expected = RenderException.class) public void testOnRenderThrowsRenderExceptionOnInternalIOException() throws Exception { // GIVEN final RenderingContext rctx = mock(RenderingContext.class); doThrow(new IOException()).when(rctx).getAppendable(); // WHEN renderer.onRender(null, null, rctx, null, null); // THEN // no then here - expect an RenderException as defined in @Test }
private TemplateDefinition getRequiredTemplateDefinition() { return (TemplateDefinition) getRenderingContext().getRenderableDefinition(); }
@Override public void render(RenderingContext ctx, Map<String, Object> contextObjects) throws RenderException { Node content = ctx.getCurrentContent(); InputStream stream = null; try { stream = this.getInputStream(content); final HttpServletResponse response = MgnlContext.getWebContext().getResponse(); response.setContentLength(stream.available()); if (content.hasNode(BINARY_NODE) && content.getNode(BINARY_NODE).hasProperty(JcrConstants.JCR_MIMETYPE)) { final String mimeType = content.getNode(BINARY_NODE).getProperty(JcrConstants.JCR_MIMETYPE).getString(); response.setContentType(mimeType); } else if (content.hasProperty(EXTENSION_PROPERTY)) { final String extension = content.getProperty(EXTENSION_PROPERTY).getString(); final String mimeType = MIMEMapping.getMIMEType(extension); response.setContentType(mimeType); } IOUtils.copy(stream, ctx.getOutputStream()); } catch (RepositoryException e) { throw new RenderException("Can't read binary data for resource " + content, e); } catch (IOException e) { throw new RenderException("Can't write binary data to the output stream.", e); } finally { IOUtils.closeQuietly(stream); } }
/** * Returns the "current content" from the aggregation state. Override this method if your component needs a * different target node. */ protected Node currentContent() { return renderingContext.getCurrentContent(); }
@Test public void testRenderThrowsRenderExceptionAndTheExceptionHandlerIsInvocedInCaseOfInternalIOException() throws Exception { // GIVEN final Node content = new MockNode("parent"); TemplateDefinitionAssignment templateDefinitionAssignment = mock(TemplateDefinitionAssignment.class); RenderingContext renderingCtx = mock(RenderingContext.class); DefaultRenderingEngine renderingEngine = createDefaultRenderingEngine(rendererRegistry, templateDefinitionAssignment, renderingCtx); TemplateDefinition templateDefinition = mock(TemplateDefinition.class); when(templateDefinitionAssignment.getAssignedTemplateDefinition(content)).thenReturn(templateDefinition); when(templateDefinition.getRenderType()).thenReturn(FREEMARKER_RENDERER_TYPE); Renderer renderer = registerMockRenderer(rendererRegistry); final StringBuilder builder = new StringBuilder(); OutputProvider builderWrapper = new AppendableOnlyOutputProvider(builder); final AppendableWriter writer = new AppendableWriter(builder); when(renderingCtx.getAppendable()).thenReturn(writer); final RenderException renderException = new RenderException("oh - oh!"); doThrow(renderException).when(renderer).render(renderingCtx, DefaultRenderingEngine.EMPTY_CONTEXT); doThrow(new IOException()).when(renderingCtx).getAppendable(); // WHEN renderingEngine.render(content, builderWrapper); // THEN - no code here as we expect an Exception verify(renderingCtx).handleException(renderException); }
@Override protected void onRender(Node content, RenderableDefinition definition, RenderingContext renderingCtx, Map<String, Object> ctx, String templateScript) throws RenderException { List<ContentMap> components = null; if (ctx.get(AreaElement.ATTRIBUTE_COMPONENT) instanceof ContentMap) { components = new ArrayList<ContentMap>(); components.add((ContentMap) ctx.get(AreaElement.ATTRIBUTE_COMPONENT)); } else if (ctx.get(AreaElement.ATTRIBUTE_COMPONENTS) instanceof List) { components = (List<ContentMap>) ctx.get(AreaElement.ATTRIBUTE_COMPONENTS); } else { return; // nothing to render } try { Appendable out = renderingCtx.getOutputProvider().getAppendable(); for (ContentMap component : components) { ComponentElement componentElement = Components.newInstance(ComponentElement.class); componentElement.setContent(component.getJCRNode()); componentElement.begin(out); componentElement.end(out); } } catch (Exception e) { throw new RenderException(e); } }
@Test(expected = RenderException.class) public void testRenderWithTemplateScriptBeingNull() throws Exception { // GIVEN Map<String, Object> contextObjects = new LinkedHashMap<String, Object>(); RenderableDefinition definition = mock(RenderableDefinition.class); when(definition.getModelClass()).thenReturn(DummyModel.class); when(ctx.getCurrentContent()).thenReturn(content); when(ctx.getRenderableDefinition()).thenReturn(definition); AbstractRenderer renderer = new DummyRenderer() { @Override protected String resolveTemplateScript(Node content, RenderableDefinition definition, RenderingModel<?> model, String actionResult) { return null; } }; // WHEN renderer.render(ctx, contextObjects); // THEN - expected Exception }
AppendableWriter out = renderingCtx.getAppendable();
protected TemplateDefinition resolveTemplateDefinition() throws RenderException { RenderableDefinition renderableDefinition = getRenderingContext().getRenderableDefinition(); RenderableDefinition variation = variationResolver.resolveVariation(renderableDefinition); renderableDefinition = variation == null ? renderableDefinition : variation; if (renderableDefinition == null || renderableDefinition instanceof TemplateDefinition) { return (TemplateDefinition) renderableDefinition; } throw new RenderException("Current RenderableDefinition [" + renderableDefinition + "] is not of type TemplateDefinition. Areas cannot be supported"); }
@Test(expected = RenderException.class) public void testRenderWhenGetIdentifierThrowsException() throws RepositoryException, RenderException { // GIVEN Node content = mock(Node.class); doThrow(new RepositoryException()).when(content).getIdentifier(); AbstractRenderer renderer = new DummyRenderer(); when(ctx.getCurrentContent()).thenReturn(content); // WHEN renderer.render(ctx, null); // THEN - expect Exception in line above... }
@Test public void testRenderExceptionHandlerIsInvokedOnRenderException() throws Exception { // GIVEN final Node content = new MockNode("parent"); TemplateDefinitionAssignment templateDefinitionAssignment = mock(TemplateDefinitionAssignment.class); RenderingContext renderingCtx = mock(RenderingContext.class); DefaultRenderingEngine renderingEngine = createDefaultRenderingEngine(rendererRegistry, templateDefinitionAssignment, renderingCtx); TemplateDefinition templateDefinition = mock(TemplateDefinition.class); when(templateDefinitionAssignment.getAssignedTemplateDefinition(content)).thenReturn(templateDefinition); Renderer renderer = registerMockRenderer(rendererRegistry); final StringBuilder builder = new StringBuilder(); OutputProvider builderWrapper = new AppendableOnlyOutputProvider(builder); final AppendableWriter writer = new AppendableWriter(builder); when(renderingCtx.getAppendable()).thenReturn(writer); when(templateDefinition.getRenderType()).thenReturn(FREEMARKER_RENDERER_TYPE); final RenderException e = new RenderException("TEST!"); doThrow(e).when(renderer).render(renderingCtx, DefaultRenderingEngine.EMPTY_CONTEXT); // WHEN renderingEngine.render(content, builderWrapper); // THEN verify(renderingCtx).handleException(e); }
@Override public void render(final RenderingContext renderingCtx, Map<String, Object> contextObjects) throws RenderException { Node content = renderingCtx.getCurrentContent(); try { RenderableDefinition renderableDefinition = renderingCtx.getRenderableDefinition(); // Merge in case of a page if (content != null && NodeUtil.isNodeType(content, NodeTypes.Page.NAME)) { final Site site = getSite(content); renderableDefinition = BeanMergerUtil.merge(renderableDefinition, site.getTemplates().getPrototype(), fallbackTemplateDefinition.getFallbackTemplateDefinition()); } renderingCtx.push(content, renderableDefinition); try { super.render(renderingCtx, contextObjects); } finally { renderingCtx.pop(); } } catch (RepositoryException e) { throw new RenderException(String.format("Could not determine node type of node [%s]", content), e); } }
try path = renderingContext.getCurrentContent().getPath(); String id = renderingContext.getRenderableDefinition().getId(); PrintWriter out = getPrintWriterFor(renderingContext.getAppendable()); out.write("\n <!-- "); out.write(msg);
@Test public void testRender() throws Exception { // GIVEN Map<String, Object> contextObjects = new LinkedHashMap<String, Object>(); RenderableDefinition definition = mock(RenderableDefinition.class); when(definition.getModelClass()).thenReturn(DummyModel.class); when(ctx.getCurrentContent()).thenReturn(content); when(ctx.getRenderableDefinition()).thenReturn(definition); DummyRenderer renderer = new DummyRenderer(); // WHEN renderer.render(ctx, contextObjects); // THEN assertTrue(renderer.wasOnRenderCalled()); assertEquals(parentModel, MgnlContext.getAttribute(AbstractRenderer.MODEL_ATTRIBUTE)); }
@Test public void testOnRender() throws Exception { // GIVEN final RenderingContext rctx = mock(RenderingContext.class); final AppendableWriter writer = mock(AppendableWriter.class); when(rctx.getAppendable()).thenReturn(writer); final ConfiguredRenderableDefinition rd = new ConfiguredRenderableDefinition(); final String i18nBasename = "basename"; rd.setI18nBasename(i18nBasename); // WHEN renderer.onRender(null, rd, rctx, null, null); // THEN verify(renderer.getFmHelper()).render(null, null, i18nBasename, null, writer); }