InternalTemplateManager.java

/*
 * See the NOTICE file distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package com.xpn.xwiki.internal.template;

import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Type;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Provider;
import javax.inject.Singleton;

import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.xwiki.component.annotation.Component;
import org.xwiki.component.manager.ComponentLookupException;
import org.xwiki.component.manager.ComponentManager;
import org.xwiki.configuration.ConfigurationSource;
import org.xwiki.environment.Environment;
import org.xwiki.filter.input.InputSource;
import org.xwiki.filter.input.InputStreamInputSource;
import org.xwiki.filter.input.ReaderInputSource;
import org.xwiki.filter.input.StringInputSource;
import org.xwiki.job.event.status.JobProgressManager;
import org.xwiki.model.reference.DocumentReference;
import org.xwiki.model.reference.DocumentReferenceResolver;
import org.xwiki.properties.BeanManager;
import org.xwiki.properties.ConverterManager;
import org.xwiki.properties.PropertyException;
import org.xwiki.properties.RawProperties;
import org.xwiki.properties.annotation.PropertyId;
import org.xwiki.rendering.block.Block;
import org.xwiki.rendering.block.GroupBlock;
import org.xwiki.rendering.block.RawBlock;
import org.xwiki.rendering.block.VerbatimBlock;
import org.xwiki.rendering.block.WordBlock;
import org.xwiki.rendering.block.XDOM;
import org.xwiki.rendering.internal.transformation.MutableRenderingContext;
import org.xwiki.rendering.parser.ContentParser;
import org.xwiki.rendering.renderer.BlockRenderer;
import org.xwiki.rendering.renderer.printer.WikiPrinter;
import org.xwiki.rendering.renderer.printer.WriterWikiPrinter;
import org.xwiki.rendering.syntax.Syntax;
import org.xwiki.rendering.transformation.RenderingContext;
import org.xwiki.rendering.transformation.TransformationContext;
import org.xwiki.rendering.transformation.TransformationManager;
import org.xwiki.security.authorization.AuthorExecutor;
import org.xwiki.skin.Resource;
import org.xwiki.skin.ResourceRepository;
import org.xwiki.skin.Skin;
import org.xwiki.template.Template;
import org.xwiki.template.TemplateContent;
import org.xwiki.velocity.VelocityManager;

import com.xpn.xwiki.XWiki;
import com.xpn.xwiki.internal.skin.AbstractEnvironmentResource;
import com.xpn.xwiki.internal.skin.InternalSkinManager;
import com.xpn.xwiki.internal.skin.WikiResource;
import com.xpn.xwiki.user.api.XWikiRightService;

/**
 * Internal toolkit to experiment on templates.
 *
 * @version $Id: f3da3fa5f9607d3128d68ae13fe09bb7ea9fecc2 $
 * @since 7.0M1
 */
@Component(roles = InternalTemplateManager.class)
@Singleton
public class InternalTemplateManager
{
    private static final Pattern PROPERTY_LINE = Pattern.compile("^##!(.+)=(.*)$\r?\n?", Pattern.MULTILINE);

    /**
     * The reference of the superadmin user.
     */
    private static final DocumentReference SUPERADMIN_REFERENCE =
        new DocumentReference("xwiki", XWiki.SYSTEM_SPACE, XWikiRightService.SUPERADMIN_USER);

    @Inject
    private Environment environment;

    @Inject
    private ContentParser parser;

    @Inject
    private VelocityManager velocityManager;

    /**
     * Used to execute transformations.
     */
    @Inject
    private TransformationManager transformationManager;

    @Inject
    @Named("context")
    private Provider<ComponentManager> componentManagerProvider;

    @Inject
    private RenderingContext renderingContext;

    @Inject
    @Named("plain/1.0")
    private BlockRenderer plainRenderer;

    @Inject
    @Named("xwikicfg")
    private ConfigurationSource xwikicfg;

    @Inject
    @Named("all")
    private ConfigurationSource allConfiguration;

    @Inject
    @Named("currentmixed")
    private DocumentReferenceResolver<String> currentMixedDocumentReferenceResolver;

    @Inject
    private BeanManager beanManager;

    @Inject
    private ConverterManager converter;

    @Inject
    private AuthorExecutor authorExecutor;

    @Inject
    private InternalSkinManager skins;

    @Inject
    private JobProgressManager progress;

    @Inject
    private Logger logger;

    private static abstract class AbtractTemplate<T extends TemplateContent, R extends Resource<?>> implements Template
    {
        protected R resource;

        protected T content;

        public AbtractTemplate(R resource)
        {
            this.resource = resource;
        }

        @Override
        public String getId()
        {
            return this.resource.getId();
        }

        @Override
        public String getPath()
        {
            return this.resource.getPath();
        }

        @Override
        public TemplateContent getContent() throws Exception
        {
            if (this.content == null) {
                // TODO: work with streams instead of forcing String
                String strinContent;

                try (InputSource source = this.resource.getInputSource()) {
                    if (source instanceof StringInputSource) {
                        strinContent = source.toString();
                    } else if (source instanceof ReaderInputSource) {
                        strinContent = IOUtils.toString(((ReaderInputSource) source).getReader());
                    } else if (source instanceof InputStreamInputSource) {
                        // It's impossible to know the real attachment encoding, but let's assume that they respect the
                        // standard and use UTF-8 (which is required for the files located on the filesystem)
                        strinContent = IOUtils.toString(((InputStreamInputSource) source).getInputStream(),
                            StandardCharsets.UTF_8);
                    } else {
                        return null;
                    }
                }

                this.content = getContentInternal(strinContent);
            }

            return this.content;
        }

        protected abstract T getContentInternal(String content) throws Exception;

        @Override
        public String toString()
        {
            return this.resource.getId();
        }
    }

    private class EnvironmentTemplate extends AbtractTemplate<FilesystemTemplateContent, AbstractEnvironmentResource>
    {
        EnvironmentTemplate(AbstractEnvironmentResource resource)
        {
            super(resource);
        }

        @Override
        protected FilesystemTemplateContent getContentInternal(String content)
        {
            return new FilesystemTemplateContent(content);
        }
    }

    private class DefaultTemplate extends AbtractTemplate<DefaultTemplateContent, Resource<?>>
    {
        DefaultTemplate(Resource<?> resource)
        {
            super(resource);
        }

        @Override
        protected DefaultTemplateContent getContentInternal(String content)
        {
            if (this.resource instanceof WikiResource) {
                return new DefaultTemplateContent(content, ((WikiResource<?>) this.resource).getAuthorReference());
            } else {
                return new DefaultTemplateContent(content);
            }
        }
    }

    private class DefaultTemplateContent implements RawProperties, TemplateContent
    {
        // TODO: work with streams instead
        protected String content;

        protected boolean authorProvided;

        protected DocumentReference authorReference;

        @PropertyId("source.syntax")
        public Syntax sourceSyntax;

        @PropertyId("raw.syntax")
        public Syntax rawSyntax;

        protected Map<String, Object> properties = new HashMap<>();

        DefaultTemplateContent(String content)
        {
            this.content = content;

            init();
        }

        DefaultTemplateContent(String content, DocumentReference authorReference)
        {
            this(content);

            setAuthorReference(authorReference);
        }

        @Override
        public Syntax getSourceSyntax()
        {
            return this.sourceSyntax;
        }

        @Override
        public Syntax getRawSyntax()
        {
            return this.rawSyntax;
        }

        @Override
        public <T> T getProperty(String name, T def)
        {
            if (!this.properties.containsKey(name)) {
                return def;
            }

            if (def != null) {
                return getProperty(name, def.getClass());
            }

            return (T) this.properties.get(name);
        }

        @Override
        public <T> T getProperty(String name, Type type)
        {
            return converter.convert(type, this.properties.get(name));
        }

        protected void init()
        {
            Matcher matcher = PROPERTY_LINE.matcher(this.content);

            Map<String, String> map = new HashMap<>();
            while (matcher.find()) {
                String key = matcher.group(1);
                String value = matcher.group(2);

                map.put(key, value);

                // Remove the line from the content
                this.content = this.content.substring(matcher.end());
            }

            try {
                InternalTemplateManager.this.beanManager.populate(this, map);
            } catch (PropertyException e) {
                // Should never happen
                InternalTemplateManager.this.logger.error("Failed to populate properties of template", e);
            }

            // The default is xhtml to support old templates
            if (this.rawSyntax == null && this.sourceSyntax == null) {
                this.rawSyntax = Syntax.XHTML_1_0;
            }
        }

        @Override
        public String getContent()
        {
            return this.content;
        }

        @PropertyId("author")
        @Override
        public DocumentReference getAuthorReference()
        {
            return this.authorReference;
        }

        protected void setAuthorReference(DocumentReference authorReference)
        {
            this.authorReference = authorReference;
            this.authorProvided = true;
        }

        // RawProperties

        @Override
        public void set(String propertyName, Object value)
        {
            this.properties.put(propertyName, value);
        }
    }

    private class FilesystemTemplateContent extends DefaultTemplateContent
    {
        public FilesystemTemplateContent(String content)
        {
            super(content);

            // Give programming right to filesystem templates by default
            setPrivileged(true);
        }

        /**
         * {@inheritDoc}
         * <p>
         * Allow filesystem template to indicate the user to executed them with.
         * </p>
         *
         * @see #setAuthorReference(DocumentReference)
         */
        @Override
        public void setAuthorReference(DocumentReference authorReference)
        {
            super.setAuthorReference(authorReference);
        }

        /**
         * Made public to be seen as bean property.
         *
         * @since 6.3.1
         * @since 6.4M1
         */
        @SuppressWarnings("unused")
        public boolean isPrivileged()
        {
            return SUPERADMIN_REFERENCE.equals(getAuthorReference());
        }

        /**
         * Made public to be seen as bean property.
         *
         * @since 6.3.1
         * @since 6.4M1
         */
        public void setPrivileged(boolean privileged)
        {
            if (privileged) {
                setAuthorReference(SUPERADMIN_REFERENCE);
            } else {
                // Reset author
                this.authorReference = null;
                this.authorProvided = false;
            }
        }
    }

    private String getResourcePath(String suffixPath, String templateName, boolean testExist)
    {
        String templatePath = suffixPath + templateName;

        // Prevent inclusion of templates from other directories
        String normalizedTemplate = URI.create(templatePath).normalize().toString();
        if (!normalizedTemplate.startsWith(suffixPath)) {
            this.logger.warn("Direct access to template file [{}] refused. Possible break-in attempt!",
                normalizedTemplate);

            return null;
        }

        if (testExist) {
            // Check if the resource exist
            if (this.environment.getResource(templatePath) == null) {
                return null;
            }
        }

        return templatePath;
    }

    private void renderError(Throwable throwable, Writer writer)
    {
        XDOM xdom = generateError(throwable);

        render(xdom, writer);
    }

    private XDOM generateError(Throwable throwable)
    {
        List<Block> errorBlocks = new ArrayList<Block>();

        // Add short message
        Map<String, String> errorBlockParams = Collections.singletonMap("class", "xwikirenderingerror");
        errorBlocks.add(
            new GroupBlock(Arrays.<Block>asList(new WordBlock("Failed to render step content")), errorBlockParams));

        // Add complete error
        StringWriter writer = new StringWriter();
        throwable.printStackTrace(new PrintWriter(writer));
        Block descriptionBlock = new VerbatimBlock(writer.toString(), false);
        Map<String, String> errorDescriptionBlockParams =
            Collections.singletonMap("class", "xwikirenderingerrordescription hidden");
        errorBlocks.add(new GroupBlock(Arrays.asList(descriptionBlock), errorDescriptionBlockParams));

        return new XDOM(errorBlocks);
    }

    private void transform(Block block)
    {
        TransformationContext txContext =
            new TransformationContext(block instanceof XDOM ? (XDOM) block : new XDOM(Arrays.asList(block)),
                this.renderingContext.getDefaultSyntax(), this.renderingContext.isRestricted());

        txContext.setId(this.renderingContext.getTransformationId());
        txContext.setTargetSyntax(getTargetSyntax());

        try {
            this.transformationManager.performTransformations(block, txContext);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param templateName the template to parse
     * @return the result of the template parsing
     */
    public XDOM getXDOMNoException(String templateName)
    {
        XDOM xdom;

        try {
            xdom = getXDOM(templateName);
        } catch (Throwable e) {
            this.logger.error("Error while getting template [{}] XDOM", templateName, e);

            xdom = generateError(e);
        }

        return xdom;
    }

    /**
     * @param template the template to parse
     * @return the result of the template parsing
     * @since 8.3RC1
     */
    public XDOM getXDOMNoException(Template template)
    {
        XDOM xdom;

        try {
            xdom = getXDOM(template);
        } catch (Throwable e) {
            this.logger.error("Error while getting template [{}] XDOM", template.getId(), e);

            xdom = generateError(e);
        }

        return xdom;
    }

    public XDOM getXDOM(Template template) throws Exception
    {
        XDOM xdom;

        if (template != null) {
            DefaultTemplateContent content = (DefaultTemplateContent) template.getContent();

            xdom = getXDOM(template, content);
        } else {
            xdom = new XDOM(Collections.<Block>emptyList());
        }

        return xdom;
    }

    private XDOM getXDOM(Template template, DefaultTemplateContent content) throws Exception
    {
        XDOM xdom;

        if (content.sourceSyntax != null) {
            xdom = this.parser.parse(content.content, content.sourceSyntax);
        } else {
            String result = evaluateContent(template, content);
            xdom = new XDOM(Arrays.asList(new RawBlock(result, content.rawSyntax)));
        }

        return xdom;
    }

    public XDOM getXDOM(String templateName) throws Exception
    {
        Template template = getTemplate(templateName);

        return getXDOM(template);
    }

    public String renderNoException(String template)
    {
        Writer writer = new StringWriter();

        renderNoException(template, writer);

        return writer.toString();
    }

    public void renderNoException(String templateName, Writer writer)
    {
        try {
            render(templateName, writer);
        } catch (Exception e) {
            this.logger.error("Error while rendering template [{}]", templateName, e);

            renderError(e, writer);
        }
    }

    /**
     * @since 8.3RC1
     */
    public void renderNoException(Template template, Writer writer)
    {
        try {
            render(template, writer);
        } catch (Exception e) {
            this.logger.error("Error while rendering template [{}]", template, e);

            renderError(e, writer);
        }
    }

    public String render(String templateName) throws Exception
    {
        return renderFromSkin(templateName, (Skin) null);
    }

    public String renderFromSkin(String templateName, String skinId) throws Exception
    {
        Skin skin = this.skins.getSkin(skinId);

        return skin != null ? renderFromSkin(templateName, skin) : null;
    }

    public String renderFromSkin(String templateName, Skin skin) throws Exception
    {
        Writer writer = new StringWriter();

        renderFromSkin(templateName, skin, writer);

        return writer.toString();
    }

    public void render(String templateName, Writer writer) throws Exception
    {
        renderFromSkin(templateName, null, writer);
    }

    public void renderFromSkin(final String templateName, ResourceRepository reposirory, final Writer writer)
        throws Exception
    {
        this.progress.startStep(templateName, "template.render.message", "Render template [{}]", templateName);

        try {
            final Template template =
                reposirory != null ? getTemplate(templateName, reposirory) : getTemplate(templateName);

            if (template != null) {
                final DefaultTemplateContent content = (DefaultTemplateContent) template.getContent();

                if (content.authorProvided) {
                    this.authorExecutor.call(() -> {
                        render(template, content, writer);

                        return null;
                    }, content.getAuthorReference());
                } else {
                    render(template, content, writer);
                }
            }
        } finally {
            this.progress.endStep(templateName);
        }
    }

    public void render(Template template, Writer writer) throws Exception
    {
        DefaultTemplateContent content = (DefaultTemplateContent) template.getContent();

        render(template, content, writer);
    }

    private void render(Template template, DefaultTemplateContent content, Writer writer) throws Exception
    {
        if (content.sourceSyntax != null) {
            XDOM xdom = execute(template, content);

            render(xdom, writer);
        } else {
            evaluateContent(template, content, writer);
        }
    }

    private void render(XDOM xdom, Writer writer)
    {
        WikiPrinter printer = new WriterWikiPrinter(writer);

        BlockRenderer blockRenderer;
        try {
            blockRenderer =
                this.componentManagerProvider.get().getInstance(BlockRenderer.class, getTargetSyntax().toIdString());
        } catch (ComponentLookupException e) {
            blockRenderer = this.plainRenderer;
        }

        blockRenderer.render(xdom, printer);
    }

    public XDOM executeNoException(String templateName)
    {
        XDOM xdom;

        try {
            xdom = execute(templateName);
        } catch (Throwable e) {
            this.logger.error("Error while executing template [{}]", templateName, e);

            xdom = generateError(e);
        }

        return xdom;
    }

    /**
     * @since 8.3RC1
     */
    public XDOM executeNoException(Template template)
    {
        XDOM xdom;

        try {
            xdom = execute(template);
        } catch (Throwable e) {
            this.logger.error("Error while executing template [{}]", template.getId(), e);

            xdom = generateError(e);
        }

        return xdom;
    }

    private XDOM execute(Template template, DefaultTemplateContent content) throws Exception
    {
        XDOM xdom = getXDOM(template, content);

        transform(xdom);

        return xdom;
    }

    public XDOM execute(String templateName) throws Exception
    {
        final Template template = getTemplate(templateName);

        if (template != null) {
            final DefaultTemplateContent content = (DefaultTemplateContent) template.getContent();

            if (content.authorProvided) {
                return this.authorExecutor.call(() -> execute(template, content), content.getAuthorReference());
            } else {
                return execute(template, content);
            }
        }

        return null;
    }

    public XDOM execute(Template template) throws Exception
    {
        if (template != null) {
            final DefaultTemplateContent content = (DefaultTemplateContent) template.getContent();

            if (content.authorProvided) {
                return this.authorExecutor.call(() -> execute(template, content), content.getAuthorReference());
            } else {
                return execute(template, content);
            }
        }

        return null;
    }

    private String evaluateContent(Template template, DefaultTemplateContent content) throws Exception
    {
        Writer writer = new StringWriter();

        evaluateContent(template, content, writer);

        return writer.toString();
    }

    private void evaluateContent(Template template, DefaultTemplateContent content, Writer writer) throws Exception
    {
        // Use the Transformation id as the name passed to the Velocity Engine. This name is used internally
        // by Velocity as a cache index key for caching macros.
        String namespace = this.renderingContext.getTransformationId();

        boolean renderingContextPushed = false;
        if (namespace == null) {
            namespace = template.getId() != null ? template.getId() : "unknown namespace";

            if (this.renderingContext instanceof MutableRenderingContext) {
                // Make the current velocity template id available
                ((MutableRenderingContext) this.renderingContext).push(this.renderingContext.getTransformation(),
                    this.renderingContext.getXDOM(), this.renderingContext.getDefaultSyntax(), namespace,
                    this.renderingContext.isRestricted(), this.renderingContext.getTargetSyntax());

                renderingContextPushed = true;
            }
        }

        try {
            this.velocityManager.evaluate(writer, namespace, new StringReader(content.content));
        } finally {
            // Get rid of temporary rendering context
            if (renderingContextPushed) {
                ((MutableRenderingContext) this.renderingContext).pop();
            }
        }
    }

    private Syntax getTargetSyntax()
    {
        Syntax targetSyntax = this.renderingContext.getTargetSyntax();

        return targetSyntax != null ? targetSyntax : Syntax.PLAIN_1_0;
    }

    private EnvironmentTemplate getFileSystemTemplate(String suffixPath, String templateName)
    {
        String path = getResourcePath(suffixPath, templateName, true);

        return path != null
            ? new EnvironmentTemplate(new TemplateEnvironmentResource(path, templateName, this.environment)) : null;
    }

    private Template getClassloaderTemplate(String suffixPath, String templateName)
    {
        return getClassloaderTemplate(Thread.currentThread().getContextClassLoader(), suffixPath, templateName);
    }

    private Template getClassloaderTemplate(ClassLoader classloader, String suffixPath, String templateName)
    {
        String templatePath = suffixPath + templateName;

        URL url = classloader.getResource(templatePath);

        return url != null ? new DefaultTemplate(new ClassloaderResource(url, templateName)) : null;
    }

    private Template createTemplate(Resource<?> resource)
    {
        Template template;

        if (resource instanceof AbstractEnvironmentResource) {
            template = new EnvironmentTemplate((AbstractEnvironmentResource) resource);
        } else {
            template = new DefaultTemplate(resource);
        }

        return template;
    }

    public Template getResourceTemplate(String templateName, ResourceRepository repository)
    {
        Resource<?> resource = repository.getLocalResource(templateName);
        if (resource != null) {
            return createTemplate(resource);
        }

        return null;
    }

    public Template getTemplate(String templateName, ResourceRepository repository)
    {
        Resource<?> resource = repository.getResource(templateName);
        if (resource != null) {
            return createTemplate(resource);
        }

        return null;
    }

    public Template getTemplate(String templateName)
    {
        Template template = null;

        // Try from skin
        Skin skin = this.skins.getCurrentSkin(false);
        if (skin != null) {
            template = getTemplate(templateName, skin);
        }

        // Try from base skin if no skin is set
        if (skin == null) {
            Skin baseSkin = this.skins.getCurrentParentSkin(false);
            if (baseSkin != null) {
                template = getTemplate(templateName, baseSkin);
            }
        }

        // Try from /templates/ environment resources
        if (template == null) {
            template = getFileSystemTemplate("/templates/", templateName);
        }

        // Try from current Thread classloader
        if (template == null) {
            template = getClassloaderTemplate("templates/", templateName);
        }

        return template;
    }
}