/*

   * Licensed to the Apache Software Foundation (ASF) under one or more

   * contributor license agreements.  See the NOTICE file distributed with

   * this work for additional information regarding copyright ownership.

   * The ASF licenses this file to You under the Apache License, Version 2.0

   * (the "License"); you may not use this file except in compliance with

   * the License.  You may obtain a copy of the License at

   *

   *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.sling.servlets.post.impl.helper;

 import java.io.IOException;

 import java.util.Calendar;

 import javax.jcr.Node;

 import javax.jcr.RepositoryException;

 import javax.jcr.nodetype.NodeType;

 import javax.jcr.nodetype.NodeTypeManager;

 import javax.servlet.ServletContext;

 import org.apache.jackrabbit.util.Text;

 import  org.apache.sling.api.request.RequestParameter;

 import  org.apache.sling.api.servlets.HtmlResponse;

 public class SlingFileUploadHandler {

     // nodetype name string constants

     public static final String NT_FOLDER = "nt:folder";

     public static final String NT_FILE = "nt:file";

     public static final String NT_RESOURCE = "nt:resource";

     public static final String NT_UNSTRUCTURED = "nt:unstructured";

     // item name string constants

     public static final String JCR_CONTENT = "jcr:content";

     public static final String JCR_LASTMODIFIED = "jcr:lastModified";

     public static final String JCR_MIMETYPE = "jcr:mimeType";

     public static final String JCR_ENCODING = "jcr:encoding";

     public static final String JCR_DATA = "jcr:data";

    

     private final ServletContext servletContext;

    

     public SlingFileUploadHandler(ServletContext servletCtx) {

         this.servletContext = servletCtx;

     }

    

    public void setFile(Node parent, RequestProperty prop, HtmlResponse response)

            throws RepositoryException {

        RequestParameter value = prop.getValues()[0];

        assert !value.isFormField();

        // ignore if empty

        if (value.getSize() <= 0) {

            return;

        }

        // get node name

        String name = prop.getName();

        if (name.equals("*")) {

            name = value.getFileName();

            // strip of possible path (some browsers include the entire path)

            name = name.substring(name.lastIndexOf('/') + 1);

            name = name.substring(name.lastIndexOf('\\') + 1);

        }

        name = Text.escapeIllegalJcrChars(name);

        // check type hint. if the type is ok and extends from nt:file,

        // create an nt:file with that type. if it's invalid, drop it and let

        // the parent node type decide.

        boolean createNtFile = parent.isNodeType(NT_FOLDER);

        String typeHint = prop.getTypeHint();

        if (typeHint != null) {

            try {

                NodeTypeManager ntMgr = parent.getSession().getWorkspace().getNodeTypeManager();

                NodeType nt = ntMgr.getNodeType(typeHint);

                createNtFile = nt.isNodeType(NT_FILE);

            } catch (RepositoryException e) {

                // assuming type not valid.

                typeHint = null;

            }

        }

        // also create an nt:file if the name contains an extension

        // the rationale is that if the file name is "important" we want

        // an nt:file, and an image name with an extension is probably "important"

        if(!createNtFile && name.indexOf('.') > 0) {

            createNtFile = true;

        }

        // set empty type

        if (typeHint == null) {

            typeHint = createNtFile ? NT_FILE : NT_RESOURCE;

        }

        // remove node

        if (parent.hasNode(name)) {

            parent.getNode(name).remove();

        }

        // create nt:file node if needed

        if (createNtFile) {

            // create nt:file

            parent = parent.addNode(name, typeHint);

            response.onCreated(parent.getPath());

            name = JCR_CONTENT;

            typeHint = NT_RESOURCE;

        }

        // create resource node

        Node res = parent.addNode(name, typeHint);

        response.onCreated(res.getPath());

        // get content type

        String contentType = value.getContentType();

        if (contentType != null) {

            int idx = contentType.indexOf(';');

            if (idx > 0) {

                contentType = contentType.substring(0, idx);

            }

        }

        if (contentType == null || contentType.equals("application/octet-stream")) {

            // try to find a better content type

            contentType = this.servletContext.getMimeType(value.getFileName());

            if (contentType == null || contentType.equals("application/octet-stream")) {

                contentType = "application/octet-stream";

            }

        }

        // set properties

        response.onModified(

            res.setProperty(JCR_LASTMODIFIED, Calendar.getInstance()).getPath()

        );

        response.onModified(

            res.setProperty(JCR_MIMETYPE, contentType).getPath()

        );

        try {

            response.onModified(

                res.setProperty(JCR_DATA, value.getInputStream()).getPath()

            );

        } catch (IOException e) {

            throw new RepositoryException("Error while retrieving inputstream from parameter value.", e);

        }

    }

}