/src/main/java/com/atlassian/jira/collector/plugin/rest/TemporaryAttachmentsResource.java

package com.atlassian.jira.collector.plugin.rest;

import com.atlassian.core.util.FileSize;
import com.atlassian.jira.bc.ServiceOutcome;
import com.atlassian.jira.collector.plugin.components.Collector;
import com.atlassian.jira.config.properties.APKeys;
import com.atlassian.jira.issue.attachment.TemporaryAttachment;
import com.atlassian.jira.rest.v1.util.CacheControl;
import com.atlassian.jira.security.JiraAuthenticationContext;
import com.atlassian.jira.util.AttachmentUtils;
import com.atlassian.jira.util.I18nHelper;
import com.atlassian.jira.util.JiraVelocityUtils;
import com.atlassian.jira.web.action.issue.TemporaryAttachmentsMonitor;
import com.atlassian.jira.collector.plugin.components.CollectorService;
import com.atlassian.plugins.rest.common.multipart.FilePart;
import com.atlassian.plugins.rest.common.multipart.MultipartFormParam;
import com.atlassian.plugins.rest.common.security.AnonymousAllowed;
import com.atlassian.templaterenderer.TemplateRenderer;
import org.apache.log4j.Logger;
import webwork.config.Configuration;

import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Collection;
import java.util.Map;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path ("tempattachment")
@Produces ( { MediaType.APPLICATION_JSON })
@Consumes ( { MediaType.TEXT_HTML })
@AnonymousAllowed
public class TemporaryAttachmentsResource
{
    private static final Logger log = Logger.getLogger(TemporaryAttachmentsResource.class);
    public static final long UNKNOWN_ISSUE_ID = -1L;

    private final CollectorService collectorService;
    private final JiraAuthenticationContext authenticationContext;
    private final TemplateRenderer templateRenderer;

    @Context
    private HttpServletRequest request;


    public TemporaryAttachmentsResource(final CollectorService collectorService, final JiraAuthenticationContext authenticationContext,
            final TemplateRenderer templateRenderer)
    {

        this.collectorService = collectorService;
        this.authenticationContext = authenticationContext;
        this.templateRenderer = templateRenderer;
    }

    @POST
    @Path ("{collectorId}")
    @Consumes ( { MediaType.MULTIPART_FORM_DATA })
    @Produces ( { MediaType.TEXT_HTML })
    public Response attachTemporaryFile(@PathParam ("collectorId") String collectorId, @MultipartFormParam ("screenshot") Collection<FilePart> fileParts)
    {
        //check if the collector exists!
        final ServiceOutcome<Collector> outcome = collectorService.getCollector(collectorId);
        if (outcome.getReturnedValue() == null || !outcome.getReturnedValue().isEnabled())
        {
            return Response.status(Response.Status.NOT_FOUND).cacheControl(CacheControl.NO_CACHE).build();
        }

        final Collector collector = outcome.getReturnedValue();
        final I18nHelper i18n = authenticationContext.getI18nHelper();

        //check if we can get an attachments monitor
        final TemporaryAttachmentsMonitor temporaryAttachmentsMonitor = TemporaryAttachmentsMonitorLocator.getAttachmentsMonitor(request, collector.getId());
        if (temporaryAttachmentsMonitor == null)
        {
            return Response.serverError().cacheControl(CacheControl.NO_CACHE).build();
        }

        //do some basic validation
        final Map<String, Object> context = JiraVelocityUtils.createVelocityParams(authenticationContext);
        if (fileParts.size() != 1)
        {
            context.put("errorMsg", i18n.getText("collector.plugin.template.error.no.attachments"));
            String out = renderTemplate("templates/rest/tempfilejson.vm", context);
            if (out == null)
            {
                return Response.serverError().cacheControl(CacheControl.NO_CACHE).build();
            }
            return Response.status(Response.Status.BAD_REQUEST).entity(out).cacheControl(CacheControl.NO_CACHE).build();
        }


        //ensure the file is not larger than a certain size!
        final FilePart filePart = fileParts.iterator().next();
        try
        {
            int maxAttachmentSize = new Integer(Configuration.getString(APKeys.JIRA_ATTACHMENT_SIZE));
            if (filePart.getInputStream().available() > maxAttachmentSize)
            {
                context.put("errorMsg", i18n.getText("collector.plugin.template.error.attachment.large", FileSize.format(maxAttachmentSize)));
                String out = renderTemplate("templates/rest/tempfilejson.vm", context);
                if (out == null)
                {
                    return Response.serverError().cacheControl(CacheControl.NO_CACHE).build();
                }
                return Response.status(Response.Status.BAD_REQUEST).entity(out).cacheControl(CacheControl.NO_CACHE).build();
            }
        }
        catch (IOException e)
        {
            return Response.serverError().cacheControl(CacheControl.NO_CACHE).build();
        }

        //finally create the temporary attachment!
        final TemporaryAttachment temporaryAttachment = createTemporaryAttachment(filePart);
        temporaryAttachmentsMonitor.add(temporaryAttachment);
        context.put("temporaryAttachment", temporaryAttachment);

        String out = renderTemplate("templates/rest/tempfilejson.vm", context);
        if (out == null)
        {
            return Response.serverError().cacheControl(CacheControl.NO_CACHE).build();
        }
        return Response.ok(out).cacheControl(CacheControl.NO_CACHE).build();
    }

    private TemporaryAttachment createTemporaryAttachment(final FilePart filePart)
    {
        final File tmpDir = AttachmentUtils.getTemporaryAttachmentDirectory();
        long uniqueId;
        File tempAttachmentFile;
        do
        {
            //if the file already exists, choose a new UUID to avoid clashes!
            uniqueId = getUUID();
            tempAttachmentFile = new File(tmpDir, uniqueId + "_" + filePart.getName());
        }
        while (tempAttachmentFile.exists());

        try
        {
            filePart.write(tempAttachmentFile);
        }
        catch (IOException e)
        {
            log.error("Error creating temporary attachment", e);
            return null;
        }

        return new TemporaryAttachment(uniqueId, UNKNOWN_ISSUE_ID, tempAttachmentFile, filePart.getName(), filePart.getContentType());
    }

    private String renderTemplate(String templatePath, Map<String, Object> context)
    {
        final StringWriter out = new StringWriter();
        try
        {
            templateRenderer.render(templatePath, context, out);
        }
        catch (IOException e)
        {
            log.error("Error rendering template '" + templatePath + "'.", e);
            return null;
        }
        return out.toString();
    }


    private long getUUID()
    {
        return Math.abs(UUID.randomUUID().getLeastSignificantBits());
    }
}