/*
* #%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 .
* #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 model)
{
return apiFacet.getScriptService().executeScript(new ClasspathScriptLocation(classpath.substring(1)),
model);
}
@Override
public Object executeScript(NodeRef templateNodeRef, Map 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 getAspects(NodeRef nodeRef)
{
NodeService nodeService = apiFacet.getNodeService();
return nodeService.getAspects(nodeRef);
}
@Override
public NodeRef getTargetAssocs(NodeRef nodeRef, QName associationQName)
{
List 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 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 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 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);
}
}