/*
* Copyright (C) 2003-2009 eXo Platform SAS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see<http://www.gnu.org/licenses/>.
*/
package org.exoplatform.services.cms.webdav;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.GregorianCalendar;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import javax.jcr.Item;
import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.HEAD;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import org.apache.commons.lang.StringUtils;
import org.exoplatform.common.http.HTTPStatus;
import org.exoplatform.common.util.HierarchicalProperty;
import org.exoplatform.commons.utils.MimeTypeResolver;
import org.exoplatform.container.xml.InitParams;
import org.exoplatform.ecm.utils.text.Text;
import org.exoplatform.services.cms.CmsService;
import org.exoplatform.services.cms.documents.AutoVersionService;
import org.exoplatform.services.cms.drives.DriveData;
import org.exoplatform.services.cms.drives.ManageDriveService;
import org.exoplatform.services.cms.impl.Utils;
import org.exoplatform.services.cms.jcrext.activity.ActivityCommonService;
import org.exoplatform.services.cms.link.LinkUtils;
import org.exoplatform.services.cms.link.NodeFinder;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.jcr.ext.app.ThreadLocalSessionProviderService;
import org.exoplatform.services.jcr.webdav.util.InitParamsDefaults;
import org.exoplatform.services.jcr.webdav.util.TextUtil;
import org.exoplatform.services.listener.ListenerService;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.exoplatform.services.rest.ExtHttpHeaders;
import org.exoplatform.services.rest.ext.webdav.method.ACL;
import org.exoplatform.services.rest.ext.webdav.method.CHECKIN;
import org.exoplatform.services.rest.ext.webdav.method.CHECKOUT;
import org.exoplatform.services.rest.ext.webdav.method.COPY;
import org.exoplatform.services.rest.ext.webdav.method.LOCK;
import org.exoplatform.services.rest.ext.webdav.method.MKCOL;
import org.exoplatform.services.rest.ext.webdav.method.MOVE;
import org.exoplatform.services.rest.ext.webdav.method.OPTIONS;
import org.exoplatform.services.rest.ext.webdav.method.ORDERPATCH;
import org.exoplatform.services.rest.ext.webdav.method.PROPFIND;
import org.exoplatform.services.rest.ext.webdav.method.PROPPATCH;
import org.exoplatform.services.rest.ext.webdav.method.REPORT;
import org.exoplatform.services.rest.ext.webdav.method.SEARCH;
import org.exoplatform.services.rest.ext.webdav.method.UNCHECKOUT;
import org.exoplatform.services.rest.ext.webdav.method.UNLOCK;
import org.exoplatform.services.rest.ext.webdav.method.VERSIONCONTROL;
import org.exoplatform.services.rest.impl.MultivaluedMapImpl;
import org.exoplatform.services.wcm.core.NodetypeConstant;
import org.exoplatform.services.wcm.utils.WCMCoreUtils;
/**
* This class is used to override the default WebDavServiceImpl in order to support symlinks
*
* Created by The eXo Platform SAS
* Author : eXoPlatform
* nicolas.filotto@exoplatform.com
* 9 avr. 2009
*/
@Path("/jcr/")
public class WebDavServiceImpl extends org.exoplatform.services.jcr.webdav.WebDavServiceImpl {
/**
* Logger.
*/
private static final Log LOG = ExoLogger.getLogger(WebDavServiceImpl.class.getName());
private final String POST_UPLOAD_CONTENT_EVENT = "WebDavService.event.postUpload";
private final String PERSONAL_DRIVE_PREFIX = "/Users/${userId}/Private";
private final String GROUP_DRIVE_PREFIX = "/Groups${groupId}/Documents";
private final String PERSONAL_GROUP_DRIVE_WORKSPACE = "collaboration";
private final NodeFinder nodeFinder;
private final RepositoryService repositoryService;
private ListenerService listenerService;
private final MimeTypeResolver mimeTypeResolver;
public WebDavServiceImpl(InitParams params,
RepositoryService repositoryService,
ThreadLocalSessionProviderService sessionProviderService,
NodeFinder nodeFinder, AutoVersionService autoVersionService, ManageDriveService manageDriveService) throws Exception
{
super(params, repositoryService, sessionProviderService);
this.repositoryService = repositoryService;
this.nodeFinder = nodeFinder;
this.listenerService = WCMCoreUtils.getService(ListenerService.class);
this.mimeTypeResolver = new MimeTypeResolver();
this.mimeTypeResolver.setDefaultMimeType(InitParamsDefaults.FILE_MIME_TYPE);
List<String> lstDriveAutoVersion = autoVersionService.getDriveAutoVersion();
MultivaluedMap<String, String> allowedAutoVersionPath = new MultivaluedMapImpl();
if (!lstDriveAutoVersion.isEmpty())
{
for (String driverName : lstDriveAutoVersion)
{
DriveData driveData = manageDriveService.getDriveByName(StringUtils.trim(driverName));
if (driveData != null)
{
String driveHome = driveData.getHomePath();
String workspace = driveData.getWorkspace();
if (driveHome.startsWith(PERSONAL_DRIVE_PREFIX) && PERSONAL_GROUP_DRIVE_WORKSPACE.equals(workspace))
{
allowedAutoVersionPath.add(driveData.getWorkspace(), "/Users");
}
else if (driveHome.startsWith(GROUP_DRIVE_PREFIX) && PERSONAL_GROUP_DRIVE_WORKSPACE.equals(workspace))
{
allowedAutoVersionPath.add(driveData.getWorkspace(), "/Groups");
}
else
{
allowedAutoVersionPath.add(driveData.getWorkspace(), driveHome);
}
}
}
}
webDavServiceInitParams.setAllowedAutoVersionPath(allowedAutoVersionPath);
webDavServiceInitParams.setEnableAutoVersion(true);
}
private String getRealDestinationHeader(String baseURI, String repoName, String destinationHeader) {
String serverURI = baseURI + "/jcr/" + repoName;
destinationHeader = TextUtil.unescape(destinationHeader, '%');
if (!destinationHeader.startsWith(serverURI)) {
return null;
}
String destPath = destinationHeader.substring(serverURI.length() + 1);
try {
Item item = nodeFinder.getItem(workspaceName(destPath),
LinkUtils.getParentPath(path(destPath)),
true);
return item.getSession().getWorkspace().getName()
+ LinkUtils.createPath(item.getPath(), LinkUtils.getItemName(path(destPath)));
} catch (RepositoryException e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + destPath, e);
}
return null;
}
}
@CHECKIN
@Path("/{repoName}/{repoPath:.*}/")
public Response checkin(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.checkin(repoName, repoPath, lockTokenHeader, ifHeader);
}
@CHECKOUT
@Path("/{repoName}/{repoPath:.*}/")
public Response checkout(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.checkout(repoName, repoPath, lockTokenHeader, ifHeader);
}
@COPY
@Path("/{repoName}/{repoPath:.*}/")
public Response copy(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.DESTINATION) String destinationHeader,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@HeaderParam(ExtHttpHeaders.DEPTH) String depthHeader,
@HeaderParam(ExtHttpHeaders.OVERWRITE) String overwriteHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoPath = convertRepoPath(repoPath, false);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
String realDestinationHeader = getRealDestinationHeader(uriInfo.getPath(), repoName, destinationHeader);
if (realDestinationHeader != null) {
destinationHeader = realDestinationHeader;
}
return super.copy(repoName,
repoPath,
destinationHeader,
lockTokenHeader,
ifHeader,
depthHeader,
overwriteHeader,
uriInfo,
body);
}
@GET
@Path("/{repoName}/{repoPath:.*}/")
public Response get(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.RANGE) String rangeHeader,
@HeaderParam(ExtHttpHeaders.IF_MODIFIED_SINCE) String ifModifiedSince,
@HeaderParam(ExtHttpHeaders.IF_NONE_MATCH) String ifNoneMatch,
@QueryParam("version") String version,
@Context UriInfo uriInfo) {
try {
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
Response response = super.get(repoName, repoPath, rangeHeader, ifModifiedSince, ifNoneMatch, version, uriInfo);
if(HTTPStatus.OK == response.getStatus()) {
return Response.fromResponse(response)
.header("Access-Control-Allow-Origin", uriInfo.getRequestUri().getHost())
.header("Access-Control-Allow-Credentials", true)
.header("Access-Control-Allow-Methods", "ACL, CANCELUPLOAD, CHECKIN, CHECKOUT, COPY, DELETE, GET, HEAD, LOCK, MKCALENDAR, MKCOL, " +
"MOVE, OPTIONS, POST, PROPFIND, PROPPATCH, PUT, REPORT, SEARCH, UNCHECKOUT, UNLOCK, UPDATE, VERSION-CONTROL")
.header("Access-Control-Allow-Headers", "Overwrite, Destination, Content-Type, Depth, User-Agent, Translate, Range, Content-Range," +
" Timeout, X-File-Size, X-Requested-With, If-Modified-Since, X-File-Name, Cache-Control, Location, Lock-Token, If")
.header("Access-Control-Expose-Header", "DAV, content-length, Allow")
.header("Access-Control-Max-Age", 3600)
.build();
}
return response;
}
@HEAD
@Path("/{repoName}/{repoPath:.*}/")
public Response head(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@Context UriInfo uriInfo) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.head(repoName, repoPath, uriInfo);
}
@LOCK
@Path("/{repoName}/{repoPath:.*}/")
public Response lock(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@HeaderParam(ExtHttpHeaders.DEPTH) String depthHeader,
HierarchicalProperty body) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.lock(repoName, repoPath, lockTokenHeader, ifHeader, depthHeader, body);
}
@UNLOCK
@Path("/{repoName}/{repoPath:.*}/")
public Response unlock(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.unlock(repoName, repoPath, lockTokenHeader, ifHeader);
}
@OPTIONS
@Path("/{repoName}/{path:.*}/")
public Response options(@PathParam("path") String path) {
return super.options(path);
}
@ORDERPATCH
@Path("/{repoName}/{repoPath:.*}/")
public Response order(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.order(repoName, repoPath, lockTokenHeader, ifHeader, uriInfo, body);
}
@PROPFIND
@Path("/{repoName}/{repoPath:.*}/")
public Response propfind(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.DEPTH) String depthHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.propfind(repoName, repoPath, depthHeader, uriInfo, body);
}
@PROPPATCH
@Path("/{repoName}/{repoPath:.*}/")
public Response proppatch(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.proppatch(repoName, repoPath, lockTokenHeader, ifHeader, uriInfo, body);
}
@PUT
@Path("/{repoName}/{repoPath:.*}/")
public Response put(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@HeaderParam(ExtHttpHeaders.FILE_NODETYPE) String fileNodeTypeHeader,
@HeaderParam(ExtHttpHeaders.CONTENT_NODETYPE) String nodeTypeHeader,
@HeaderParam(ExtHttpHeaders.CONTENT_MIXINTYPES) String mixinTypes,
@HeaderParam(ExtHttpHeaders.CONTENTTYPE) MediaType mediaType,
@HeaderParam(ExtHttpHeaders.USER_AGENT) String userAgent,
InputStream inputStream,
@Context UriInfo uriInfo) {
Session session = null;
Item item = null;
boolean isCreating = false;
ActivityCommonService activityService = null;
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
try {
item = nodeFinder.getItem(workspaceName(repoPath),
LinkUtils.getParentPath(path(normalizePath(repoPath))),
true);
repoPath = item.getSession().getWorkspace().getName()
+ LinkUtils.createPath(item.getPath(), Text.escapeIllegalJcrChars(LinkUtils.getItemName(path(repoPath))));
session = item.getSession();
} catch (PathNotFoundException e) {
item = nodeFinder.getItem(workspaceName(repoPath),
LinkUtils.getParentPath(path(Text.escapeIllegalJcrChars(repoPath))),
true);
repoPath = item.getSession().getWorkspace().getName()
+ LinkUtils.createPath(item.getPath(), Text.escapeIllegalJcrChars(LinkUtils.getItemName(path(repoPath))));
session = item.getSession();
}
activityService = WCMCoreUtils.getService(ActivityCommonService.class);
if (!session.itemExists(path(repoPath))) {
isCreating = true;
}
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
Response res = super.put(repoName,
repoPath,
lockTokenHeader,
ifHeader,
null,
nodeTypeHeader,
mixinTypes,
mediaType,
userAgent,
inputStream,
uriInfo);
try {
boolean pushAs = markTempFilesToHidden(repoPath);
Node currentNode = (Node) session.getItem(path(repoPath));
if (isCreating) {
if (userAgent!= null && userAgent.contains("Microsoft")) {
activityService.setCreating(currentNode, true);
}
}else {
activityService.setCreating(currentNode, false);
}
try {
if(isCreating && pushAs)
listenerService.broadcast(ActivityCommonService.FILE_CREATED_ACTIVITY, null, currentNode);
if (currentNode.isCheckedOut() && !activityService.isCreating(currentNode) && pushAs)
listenerService.broadcast(this.POST_UPLOAD_CONTENT_EVENT, this, currentNode);
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot broadcast file create activity for the item at " + currentNode.getPath(), e);
}
}
} catch (PathNotFoundException npfe) {
return Response.status(HTTPStatus.NOT_FOUND).entity(npfe.getMessage()).build();
} catch (RepositoryException re) {
return Response.status(HTTPStatus.NOT_FOUND).entity(re.getMessage()).build();
} catch (Exception e) {
return Response.serverError().build();
}
return res;
}
@REPORT
@Path("/{repoName}/{repoPath:.*}/")
public Response report(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.DEPTH) String depthHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.report(repoName, repoPath, depthHeader, uriInfo, body);
}
@SEARCH
@Path("/{repoName}/{repoPath:.*}/")
public Response search(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.search(repoName, repoPath, uriInfo, body);
}
@UNCHECKOUT
@Path("/{repoName}/{repoPath:.*}/")
public Response uncheckout(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.uncheckout(repoName, repoPath, lockTokenHeader, ifHeader);
}
@VERSIONCONTROL
@Path("/{repoName}/{repoPath:.*}/")
public Response versionControl(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.versionControl(repoName, repoPath, lockTokenHeader, ifHeader);
}
@ACL
@Path("/{repoName}/{repoPath:.*}/")
public Response acl(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
HierarchicalProperty body) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.acl(repoName, repoPath, lockTokenHeader, ifHeader, body);
}
@MOVE
@Path("/{repoName}/{repoPath:.*}/")
public Response move(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.DESTINATION) String destinationHeader,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@HeaderParam(ExtHttpHeaders.DEPTH) String depthHeader,
@HeaderParam(ExtHttpHeaders.OVERWRITE) String overwriteHeader,
@Context UriInfo uriInfo,
HierarchicalProperty body) {
try {
repoPath = convertRepoPath(repoPath, true);
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
Response response = super.move(repoName,
repoPath,
destinationHeader,
lockTokenHeader,
ifHeader,
depthHeader,
overwriteHeader,
uriInfo,
body);
if (response.getStatus() == HTTPStatus.CREATED) {
updateProperties(destinationHeader, repoName);
}
markTempFilesToHidden(repoPath);
return response;
}
/**
* update exo:name, exo:title and jcr:mimeType when rename a node
*
* @param destinationHeader
* @param repoName
*/
private void updateProperties(String destinationHeader, String repoName) {
try {
URI dest = buildURI(destinationHeader);
String destPath = dest.getPath();
int repoIndex = destPath.indexOf(repoName);
destPath = normalizePath(repoIndex == -1 ? destPath : destPath.substring(repoIndex + repoName.length() + 1));
String destNodePath = path(destPath);
Node destNode = (Node) nodeFinder.getItem(workspaceName(destPath), path(normalizePath(destNodePath)), true);
String nodeName = Text.escapeIllegalJcrChars(destNode.getName());
destNode.setProperty("exo:name", nodeName);
destNode.setProperty("exo:title", nodeName);
if (!Utils.isFolder(destNode)) {
Node content = destNode.getNode("jcr:content");
String mimeType = mimeTypeResolver.getMimeType(nodeName);
content.setProperty("jcr:mimeType", mimeType);
// Change publication status
ListenerService listenerService = WCMCoreUtils.getService(ListenerService.class);
if (destNode.isNodeType("exo:datetime")) {
destNode.setProperty("exo:dateModified", new GregorianCalendar());
}
listenerService.broadcast(CmsService.POST_EDIT_CONTENT_EVENT, destNode.getParent(), destNode);
}
destNode.save();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot change property of destNode" + destinationHeader, e);
}
}
}
/**
* Build URI from string.
*/
private URI buildURI(String path) throws URISyntaxException {
try {
return new URI(path);
}
catch (URISyntaxException e) {
return new URI(TextUtil.escape(path, '%', true));
}
}
/**
* {@inheritDoc}
*/
@MKCOL
@Path("/{repoName}/{repoPath:.*}/")
public Response mkcol(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader,
@HeaderParam(ExtHttpHeaders.CONTENT_NODETYPE) String nodeTypeHeader,
@HeaderParam(ExtHttpHeaders.CONTENT_MIXINTYPES) String mixinTypesHeader,
@Context UriInfo uriInfo) {
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
Item item = nodeFinder.getItem(workspaceName(repoPath), LinkUtils.getParentPath(path(normalizePath(repoPath))), true);
repoPath =
item.getSession().getWorkspace().getName() + LinkUtils.createPath(item.getPath(),
LinkUtils.getItemName(path(repoPath)));
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.CONFLICT).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.CONFLICT).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
return super.mkcol(repoName,
repoPath,
lockTokenHeader,
ifHeader,
nodeTypeHeader,
mixinTypesHeader,
uriInfo);
}
@DELETE
@Path("/{repoName}/{repoPath:.*}/")
public Response delete(@PathParam("repoName") String repoName,
@PathParam("repoPath") String repoPath,
@HeaderParam(ExtHttpHeaders.LOCKTOKEN) String lockTokenHeader,
@HeaderParam(ExtHttpHeaders.IF) String ifHeader) {
Item item = null;
try {
repoName = repositoryService.getCurrentRepository().getConfiguration().getName();
repoPath = convertRepoPath(repoPath, false);
try {
item = nodeFinder.getItem(workspaceName(repoPath),
path(normalizePath(repoPath)),
true);
} catch (PathNotFoundException e) {
item = nodeFinder.getItem(workspaceName(repoPath),
path(Text.escapeIllegalJcrChars(repoPath)),
true);
}
} catch (PathNotFoundException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (NoSuchWorkspaceException exc) {
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Cannot find the item at " + repoName + "/" + repoPath, e);
}
return Response.serverError().build();
}
try {
//Broadcast the event when user move node to Trash
Node node = (Node)item;
ListenerService listenerService = WCMCoreUtils.getService(ListenerService.class);
ActivityCommonService activityService = WCMCoreUtils.getService(ActivityCommonService.class);
Node parent = node.getParent();
if (node.getPrimaryNodeType().getName().equals(NodetypeConstant.NT_FILE)) {
if (activityService.isBroadcastNTFileEvents(node)) {
listenerService.broadcast(ActivityCommonService.FILE_REMOVE_ACTIVITY, parent, node);
}
} else if(!WCMCoreUtils.isDocumentNodeType(node)){
Queue<Node> queue = new LinkedList<Node>();
queue.add(node);
//Broadcast event to remove file activities
Node tempNode = null;
try {
while (!queue.isEmpty()) {
tempNode = queue.poll();
if (WCMCoreUtils.isDocumentNodeType(tempNode)
|| tempNode.getPrimaryNodeType().getName().equals(NodetypeConstant.NT_FILE)) {
listenerService.broadcast(ActivityCommonService.FILE_REMOVE_ACTIVITY, tempNode.getParent(), tempNode);
} else {
for (NodeIterator iter = tempNode.getNodes(); iter.hasNext(); ) {
Node childNode = iter.nextNode();
if(WCMCoreUtils.isDocumentNodeType(childNode) || childNode.isNodeType(NodetypeConstant.NT_UNSTRUCTURED)
|| childNode.isNodeType(NodetypeConstant.NT_FOLDER))
queue.add(childNode);
}
}
}
} catch (Exception e) {
if (LOG.isWarnEnabled()) {
LOG.warn(e.getMessage());
}
}
}
//Remove the symlinks of deleted node.
Utils.removeSymlinks(node);
} catch(Exception ex) {
if (LOG.isWarnEnabled()) {
LOG.warn(ex.getMessage());
}
}
return super.delete(repoName, repoPath, lockTokenHeader, ifHeader);
}
private String convertRepoPath(String repoPath, boolean giveTarget) throws Exception{
try {
Item item = nodeFinder.getItem(workspaceName(repoPath), path(normalizePath(repoPath)), giveTarget);
return item.getSession().getWorkspace().getName() + item.getPath();
} catch (PathNotFoundException e) {
Item item = nodeFinder.getItem(workspaceName(repoPath), path(Text.escapeIllegalJcrChars(repoPath)), giveTarget);
return item.getSession().getWorkspace().getName() + item.getPath();
}
}
/**
* hidden temporary files/folders
* @param repoPath
*/
private boolean markTempFilesToHidden(String repoPath){
if(StringUtils.isBlank(repoPath)) return false;
String tempNodeFolder = ".TemporaryItems";
String tempNodeFileChild = "._folders.501";
String tempNodeFile = "._.TemporaryItems";
String txtTempRegex = "/._";
try {
String txtTemp = repoPath.substring(repoPath.lastIndexOf("/"), repoPath.length());
boolean isTxtTemp = txtTemp.startsWith(txtTempRegex)?true:false;
if(repoPath.contains(tempNodeFile) || isTxtTemp){
Node _tempNodeFile = (Node)nodeFinder.getItem(workspaceName(repoPath), path(repoPath), true);
_tempNodeFile.remove();
_tempNodeFile.getSession().save();
return false;
}else if(repoPath.contains(tempNodeFolder)) {
String currentNodePath = repoPath.substring(0, repoPath.indexOf(tempNodeFolder));
Node currentNode = (Node)nodeFinder.getItem(workspaceName(repoPath), path(currentNodePath), true);
//make tmp folder to hidden
if(currentNode.hasNode(tempNodeFolder)){
Node _tmpFolderNode = currentNode.getNode(tempNodeFolder);
if(_tmpFolderNode.canAddMixin(NodetypeConstant.EXO_HIDDENABLE)) _tmpFolderNode.addMixin(NodetypeConstant.EXO_HIDDENABLE);
if (_tmpFolderNode.hasNode(tempNodeFileChild)){
Node _tempNodeFileChild = _tmpFolderNode.getNode(tempNodeFileChild);
_tempNodeFileChild.remove();
}
_tmpFolderNode.save();
}
return false;
}
}catch(RepositoryException ex){
if (LOG.isWarnEnabled()) {
LOG.warn("The hidden temp files has been ignored " + ex.getMessage());
}
}
return true;
}
}