mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-10-22 15:12:38 +00:00
6afb44e712
125606 rmunteanu: Merged 5.1.1 (5.1.1) to 5.1.N (5.1.2)
125515 slanglois: MNT-16155 Update source headers - add new Copyrights for Java and JSP source files + automatic check in the build
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/BRANCHES/DEV/5.2.N/root@125788 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
318 lines
11 KiB
Java
318 lines
11 KiB
Java
/*
|
|
* #%L
|
|
* Alfresco Repository
|
|
* %%
|
|
* Copyright (C) 2005 - 2016 Alfresco Software Limited
|
|
* %%
|
|
* This file is part of the Alfresco software.
|
|
* If the software was purchased under a paid Alfresco license, the terms of
|
|
* the paid license agreement will prevail. Otherwise, the software is
|
|
* provided under the following open source license terms:
|
|
*
|
|
* Alfresco 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco 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 Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
* #L%
|
|
*/
|
|
|
|
package org.alfresco.repo.virtual;
|
|
|
|
import java.io.InputStream;
|
|
import java.io.Serializable;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.alfresco.model.ContentModel;
|
|
import org.alfresco.repo.jscript.ClasspathScriptLocation;
|
|
import org.alfresco.repo.model.Repository;
|
|
import org.alfresco.repo.virtual.config.NodeRefResolver;
|
|
import org.alfresco.service.ServiceRegistry;
|
|
import org.alfresco.service.cmr.dictionary.InvalidAspectException;
|
|
import org.alfresco.service.cmr.dictionary.InvalidTypeException;
|
|
import org.alfresco.service.cmr.model.FileExistsException;
|
|
import org.alfresco.service.cmr.model.FileInfo;
|
|
import org.alfresco.service.cmr.repository.AssociationRef;
|
|
import org.alfresco.service.cmr.repository.ChildAssociationRef;
|
|
import org.alfresco.service.cmr.repository.ContentReader;
|
|
import org.alfresco.service.cmr.repository.ContentWriter;
|
|
import org.alfresco.service.cmr.repository.InvalidNodeRefException;
|
|
import org.alfresco.service.cmr.repository.NodeRef;
|
|
import org.alfresco.service.cmr.repository.NodeService;
|
|
import org.alfresco.service.cmr.repository.Path;
|
|
import org.alfresco.service.cmr.search.ResultSet;
|
|
import org.alfresco.service.cmr.search.SearchParameters;
|
|
import org.alfresco.service.cmr.security.AccessStatus;
|
|
import org.alfresco.service.namespace.NamespacePrefixResolver;
|
|
import org.alfresco.service.namespace.QName;
|
|
import org.alfresco.service.namespace.QNamePattern;
|
|
import org.springframework.core.io.Resource;
|
|
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
|
|
import org.springframework.core.io.support.ResourcePatternResolver;
|
|
|
|
public class AlfrescoEnviroment implements ActualEnvironment
|
|
{
|
|
private AlfrescoAPIFacet apiFacet;
|
|
|
|
private ServiceRegistry serviceRegistry;
|
|
|
|
private NamespacePrefixResolver namespacePrefixResolver;
|
|
|
|
private Repository repositoryHelper;
|
|
|
|
private NodeRefResolver nodeRefResolver;
|
|
|
|
public void setNodeRefResolver(NodeRefResolver nodeRefResolver)
|
|
{
|
|
this.nodeRefResolver = nodeRefResolver;
|
|
}
|
|
|
|
public void setAlfrescoAPIFacet(AlfrescoAPIFacet apiFacet)
|
|
{
|
|
this.apiFacet = apiFacet;
|
|
}
|
|
|
|
public void setServiceRegistry(ServiceRegistry serviceRegistry)
|
|
{
|
|
this.serviceRegistry = serviceRegistry;
|
|
}
|
|
|
|
public ServiceRegistry getServiceRegistry()
|
|
{
|
|
return this.serviceRegistry;
|
|
}
|
|
|
|
public void setRepositoryHelper(Repository repository)
|
|
{
|
|
this.repositoryHelper = repository;
|
|
}
|
|
|
|
@Override
|
|
public Object executeScript(String classpath, Map<String, Object> model)
|
|
{
|
|
|
|
return apiFacet.getScriptService().executeScript(new ClasspathScriptLocation(classpath.substring(1)),
|
|
model);
|
|
}
|
|
|
|
@Override
|
|
public Object executeScript(NodeRef templateNodeRef, Map<String, Object> model)
|
|
{
|
|
|
|
return apiFacet.getScriptService().executeScript(templateNodeRef,
|
|
null,
|
|
model);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasAspect(final NodeRef nodeRef, final QName aspectTypeQName)
|
|
{
|
|
return apiFacet.getNodeService().hasAspect(nodeRef,
|
|
aspectTypeQName);
|
|
}
|
|
|
|
@Override
|
|
public Set<QName> getAspects(NodeRef nodeRef)
|
|
{
|
|
NodeService nodeService = apiFacet.getNodeService();
|
|
return nodeService.getAspects(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public NodeRef getTargetAssocs(NodeRef nodeRef, QName associationQName)
|
|
{
|
|
List<AssociationRef> assocs = apiFacet.getNodeService().getTargetAssocs(nodeRef,
|
|
associationQName);
|
|
|
|
if (assocs != null && assocs.size() >= 1)
|
|
{
|
|
AssociationRef associationRef = assocs.get(0);
|
|
NodeRef targetRef = associationRef.getTargetRef();
|
|
return targetRef;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Serializable getProperty(NodeRef nodeRef, QName qname)
|
|
{
|
|
return apiFacet.getNodeService().getProperty(nodeRef,
|
|
qname);
|
|
}
|
|
|
|
@Override
|
|
public Map<QName, Serializable> getProperties(NodeRef nodeRef)
|
|
{
|
|
return apiFacet.getNodeService().getProperties(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public InputStream openContentStream(NodeRef nodeRef) throws ActualEnvironmentException
|
|
{
|
|
ContentReader contentReader = apiFacet.getContentService().getReader(nodeRef,
|
|
ContentModel.PROP_CONTENT);
|
|
return contentReader.getContentInputStream();
|
|
}
|
|
|
|
@Override
|
|
public InputStream openContentStream(String classpath) throws ActualEnvironmentException
|
|
{
|
|
return getClass().getResourceAsStream(classpath);
|
|
}
|
|
|
|
@Override
|
|
public ResultSet query(SearchParameters searchParameters)
|
|
{
|
|
return apiFacet.getSearchService().query(searchParameters);
|
|
}
|
|
|
|
@Override
|
|
public Object createScriptVirtualContext(VirtualContext context) throws ActualEnvironmentException
|
|
{
|
|
return new AlfrescoScriptVirtualContext(context,
|
|
serviceRegistry);
|
|
}
|
|
|
|
@Override
|
|
public QName getType(final NodeRef nodeRef)
|
|
{
|
|
return apiFacet.getNodeService().getType(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public boolean isSubClass(QName className, QName ofClassName)
|
|
{
|
|
return apiFacet.getDictionaryService().isSubClass(className,
|
|
ofClassName);
|
|
}
|
|
|
|
public void setNamespacePrefixResolver(NamespacePrefixResolver namespacePrefixResolver)
|
|
{
|
|
this.namespacePrefixResolver = namespacePrefixResolver;
|
|
}
|
|
|
|
@Override
|
|
public NamespacePrefixResolver getNamespacePrefixResolver()
|
|
{
|
|
return namespacePrefixResolver;
|
|
}
|
|
|
|
@Override
|
|
public String getCurrentUser()
|
|
{
|
|
return serviceRegistry.getAuthenticationService().getCurrentUserName();
|
|
}
|
|
|
|
@Override
|
|
public Path getPath(NodeRef nodeRef)
|
|
{
|
|
return apiFacet.getNodeService().getPath(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public ChildAssociationRef getPrimaryParent(NodeRef nodeRef)
|
|
{
|
|
NodeService nodeService = apiFacet.getNodeService();
|
|
return nodeService.getPrimaryParent(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public List<ChildAssociationRef> getChildAssocs(NodeRef nodeRef, QNamePattern typeQNamePattern,
|
|
QNamePattern qnamePattern, int maxResults, boolean preload) throws InvalidNodeRefException
|
|
{
|
|
NodeService nodeService = apiFacet.getNodeService();
|
|
return nodeService.getChildAssocs(nodeRef,
|
|
typeQNamePattern,
|
|
qnamePattern,
|
|
maxResults,
|
|
preload);
|
|
}
|
|
|
|
@Override
|
|
public NodeRef findNodeRef(String referenceType, String[] reference)
|
|
{
|
|
return repositoryHelper.findNodeRef(referenceType,
|
|
reference);
|
|
}
|
|
|
|
@Override
|
|
public boolean exists(NodeRef nodeRef)
|
|
{
|
|
return apiFacet.getNodeService().exists(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public NodeRef getChildByName(NodeRef nodeRef, QName assocTypeQName, String childName)
|
|
{
|
|
return apiFacet.getNodeService().getChildByName(nodeRef,
|
|
assocTypeQName,
|
|
childName);
|
|
}
|
|
|
|
@Override
|
|
public void delete(NodeRef nodeRef)
|
|
{
|
|
apiFacet.getNodeService().deleteNode(nodeRef);
|
|
}
|
|
|
|
@Override
|
|
public FileInfo create(NodeRef parentNodeRef, String name, QName typeQName) throws FileExistsException
|
|
{
|
|
return apiFacet.getFileFolderService().create(parentNodeRef,
|
|
name,
|
|
typeQName);
|
|
}
|
|
|
|
@Override
|
|
public ContentWriter getWriter(NodeRef nodeRef, QName propertyQName, boolean update)
|
|
throws InvalidNodeRefException, InvalidTypeException
|
|
{
|
|
return apiFacet.getContentService().getWriter(nodeRef,
|
|
propertyQName,
|
|
update);
|
|
}
|
|
|
|
@Override
|
|
public void addAspect(NodeRef nodeRef, QName aspectTypeQName, Map<QName, Serializable> aspectProperties)
|
|
throws InvalidNodeRefException, InvalidAspectException
|
|
{
|
|
apiFacet.getNodeService().addAspect(nodeRef,
|
|
aspectTypeQName,
|
|
aspectProperties);
|
|
}
|
|
|
|
@Override
|
|
public NodeRef findQNamePath(String[] patheElements)
|
|
{
|
|
return nodeRefResolver.resolveQNameReference(patheElements);
|
|
}
|
|
|
|
@Override
|
|
public boolean exists(String classpath)
|
|
{
|
|
ClassLoader cl = this.getClass().getClassLoader();
|
|
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl);
|
|
Resource resource = resolver.getResource("classpath:" + classpath);
|
|
return resource.exists();
|
|
}
|
|
|
|
@Override
|
|
public boolean hasPermission(NodeRef nodeRef, String perm)
|
|
{
|
|
return apiFacet.getPermissionService().hasPermission(nodeRef,
|
|
perm).equals(AccessStatus.ALLOWED);
|
|
}
|
|
}
|