Java Node.hasProperty方法代码示例

import javax.jcr.Node; //导入方法依赖的package包/类
/**
 * Takes type, resource, and propertyName and returns its value of the object based on the given type
 *
 * @param type This is type parameter
 * @param resource The resource to fetch the value from
 * @param propertyName The property name to be used to fetch the value from the resource
 * @return value The value of the object based on the given type
 */
private static <T> T getSinglePropertyAs(Class<T> type, Resource resource, String propertyName) {
    T val = null;
    try {
        if (null != resource) {
            Node node = resource.adaptTo(Node.class);
            if (null != node) {
                if (node.hasProperty(propertyName)) {
                    Property property = node.getProperty(propertyName);
                    if (!property.isMultiple()) {
                        Value value = property.getValue();
                        val = PropertyUtils.as(type, value);
                    }
                }
            }
        }
    } catch (Exception e) {
        LOG.error(ERROR, e);
    }
    return val;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
/**
 * Takes type, resource, and property name and returns the list of value of the object based on the given type
 *
 * @param type This is type parameter
 * @param resource The resource to fetch the value from
 * @param propertyName The property name to be used to fetch the value from the resource
 * @return valueList The list of values of the object based on the given type
 */
private static <T> List<T> getMultiplePropertyAs(Class<T> type, Resource resource, String propertyName) {
    List<T> val = Collections.EMPTY_LIST;
    try {
        if (null != resource) {
            Node node = resource.adaptTo(Node.class);
            if (null != node) {
                if (node.hasProperty(propertyName)) {
                    Property property = node.getProperty(propertyName);
                    if (property.isMultiple()) {
                        Value[] value = property.getValues();
                        val = PropertyUtils.as(type, value);
                    }
                }
            }
        }
    } catch (Exception e) {
        LOG.error(ERROR, e);
    }
    return val;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private void buildDirectories(Node node, List<RepositoryFile> fileList, String projectPath) throws Exception {
	NodeIterator nodeIterator = node.getNodes();
	while (nodeIterator.hasNext()) {
		Node dirNode = nodeIterator.nextNode();
		if (!dirNode.hasProperty(FILE)) {
			continue;
		}
		if (!dirNode.hasProperty(DIR_TAG)) {
			continue;
		}
		RepositoryFile file = new RepositoryFile();
		file.setName(dirNode.getPath().substring(projectPath.length()));
		file.setFullPath(dirNode.getPath());
		buildDirectories(dirNode, fileList, projectPath);
		fileList.add(file);
	}
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private Value[] getPropertyValues(Node node, String propertyName) throws RepositoryException {
    if (node.hasProperty(propertyName)) {
        Property prop = node.getProperty(propertyName);
        Value[] values;

        // This check is necessary to ensure a multi-valued field is applied...
        if (prop.isMultiple()) {
            values = prop.getValues();
        } else {
            values = new Value[1];
            values[0] = prop.getValue();
        }

        return values;
    }

    return new Value[0];
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private void purge(final Context context, final ActionResult actionResult)
		throws RepositoryException, ActionExecutionException {
	NodeIterator iterator = getPermissions(context);
	String normalizedPath = normalizePath(path);
	while (iterator != null && iterator.hasNext()) {
		Node node = iterator.nextNode();
		if (node.hasProperty(PermissionConstants.REP_ACCESS_CONTROLLED_PATH)) {
			String parentPath = node.getProperty(PermissionConstants.REP_ACCESS_CONTROLLED_PATH)
					.getString();
			String normalizedParentPath = normalizePath(parentPath);
			boolean isUsersPermission = parentPath.startsWith(context.getCurrentAuthorizable().getPath());
			if (StringUtils.startsWith(normalizedParentPath, normalizedPath) && !isUsersPermission) {
				RemoveAll removeAll = new RemoveAll(parentPath);
				ActionResult removeAllResult = removeAll.execute(context);
				if (Status.ERROR.equals(removeAllResult.getStatus())) {
					actionResult.logError(removeAllResult);
				}
			}
		}
	}
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected void doGet(final SlingHttpServletRequest request, final SlingHttpServletResponse response)
        throws IOException, ServletException {
    //TODO: put all of the logic in a context processor (need to fix templating support filter bug first)
    String transformName = BLANK;
    if (PathInfoUtil.getSuffixSegments(request).length == 2) {
        String firstSuffixSegment = PathInfoUtil.getFirstSuffixSegment(request);
        if (this.namedImageTransformers.keySet().contains(firstSuffixSegment)) {
            transformName = firstSuffixSegment;
        }
    }
    //Adds the asset binary to the inputStream
    try {
        Resource assetResource = getAssetResource(request);

        if (DamUtil.isAsset(assetResource)) {
            Binary binary;
            String mimeType = BLANK;
            Asset asset = DamUtil.resolveToAsset(assetResource);
            Resource original = asset.getOriginal();

            Node assetNode = original.adaptTo(Node.class);
            if (assetNode.hasNode(JCR_CONTENT)) {
                Node assetInfo = assetNode.getNode(JCR_CONTENT);
                if (assetInfo.hasProperty(JCR_MIMETYPE)) {
                    mimeType = assetInfo.getProperty(JCR_MIMETYPE).getString();
                }
                if (StringUtils.isNotBlank(mimeType)) {
                    response.setContentType(mimeType);
                }
                binary = assetInfo.getProperty(JCR_DATA).getBinary();
                InputStream inputStream = binary.getStream();
                OutputStream outputStream = response.getOutputStream();

                boolean shouldTransform = StringUtils.isNotBlank(transformName);
                if (shouldTransform && ImageUtils.isImage(assetResource)) {
                    double quality = 1;
                    double maxGifQuality = 255;

                    // Transform the image
                    final Layer layer = new Layer(inputStream, new Dimension(maxWidth, maxHeight));
                    Layer newLayer = null;
                    try {
                        final NamedImageTransformer namedImageTransformer = this.namedImageTransformers.get(transformName);
                        newLayer = namedImageTransformer.transform(layer);

                        if (StringUtils.isBlank(mimeType) || !ImageIO.getImageWritersByMIMEType(mimeType).hasNext()) {
                            mimeType = getImageMimeType(layer, asset.getName());
                            response.setContentType(mimeType);
                        }
                        // For GIF images the colors will be reduced according to the quality argument.
                        if (StringUtils.equals(mimeType, GIF_MIME_TYPE)) {
                            quality = quality * maxGifQuality;
                        }

                        newLayer.write(mimeType, quality, outputStream);
                    } finally {
                        if (layer != null) {
                            layer.dispose();
                        }
                        if (newLayer != null) {
                            newLayer.dispose();
                        }
                    }

                } else {
                    ByteStreams.copy(inputStream, outputStream);
                }

                response.flushBuffer();
                outputStream.close();

            }
        }
    } catch (RepositoryException repoException) {
        LOGGER.error("Repository Exception. ", repoException);
    }
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public ExternalDocumentCollection<JSONObject> getFieldExternalDocuments(ExternalDocumentServiceContext context) {
    final String fieldName = context.getPluginConfig().getString(PARAM_EXTERNAL_DOCS_FIELD_NAME);

    if (StringUtils.isBlank(fieldName)) {
        throw new IllegalArgumentException("Invalid plugin configuration parameter for '" + PARAM_EXTERNAL_DOCS_FIELD_NAME + "': " + fieldName);
    }

    ExternalDocumentCollection<JSONObject> docCollection = new SimpleExternalDocumentCollection<JSONObject>();

    try {
        final Node contextNode = context.getContextModel().getNode();

        if (contextNode.hasProperty(fieldName)) {
            Value[] values = contextNode.getProperty(fieldName).getValues();

            // This is where it checks which values are selected.
            for (Value value : values) {
                String id = value.getString();
                JSONObject doc = findDocumentById(id);

                if (doc != null) {
                    docCollection.add(doc);
                }
            }
        }
    } catch (RepositoryException e) {
        log.error("Failed to retrieve related exdoc array field.", e);
    }

    return docCollection;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public List<RepositoryFile> loadProjects(String companyId) throws Exception{
	List<RepositoryFile> projects=new ArrayList<RepositoryFile>();
	Node rootNode=getRootNode();
	NodeIterator nodeIterator = rootNode.getNodes();
	while (nodeIterator.hasNext()) {
		Node projectNode = nodeIterator.nextNode();
		if (!projectNode.hasProperty(FILE)) {
			continue;
		}
		if(StringUtils.isNotEmpty(companyId)){
			if(projectNode.hasProperty(COMPANY_ID)){
				String id=projectNode.getProperty(COMPANY_ID).getString();
				if(!companyId.equals(id)){
					continue;
				}
			}
		}
		if(projectNode.getName().indexOf(RESOURCE_SECURITY_CONFIG_FILE)>-1){
			continue;
		}
		RepositoryFile projectFile = new RepositoryFile();
		projectFile.setType(Type.project);
		projectFile.setName(projectNode.getName());
		projectFile.setFullPath("/" + projectNode.getName());
		projects.add(projectFile);
	}
	return projects;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public List<VersionFile> getVersionFiles(String path) throws Exception{
	path = processPath(path);
	Node rootNode=getRootNode();
	if (!rootNode.hasNode(path)) {
		throw new RuleException("File [" + path + "] not exist.");
	}
	List<VersionFile> files = new ArrayList<VersionFile>();
	Node fileNode = rootNode.getNode(path);
	VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath());
	VersionIterator iterator = versionHistory.getAllVersions();
	while (iterator.hasNext()) {
		Version version = iterator.nextVersion();
		String versionName = version.getName();
		if (versionName.startsWith("jcr:")) {
			continue; // skip root version
		}
		Node fnode = version.getFrozenNode();
		VersionFile file = new VersionFile();
		file.setName(version.getName());
		file.setPath(fileNode.getPath());
		Property prop = fnode.getProperty(CRATE_USER);
		file.setCreateUser(prop.getString());
		prop = fnode.getProperty(CRATE_DATE);
		file.setCreateDate(prop.getDate().getTime());
		if(fnode.hasProperty(VERSION_COMMENT)){
			prop=fnode.getProperty(VERSION_COMMENT);
			file.setComment(prop.getString());
		}
		files.add(file);
	}
	return files;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public List<RepositoryFile> getDirectories(String project) throws Exception {
	Node rootNode=getRootNode();
	NodeIterator nodeIterator = rootNode.getNodes();
	Node targetProjectNode = null;
	while (nodeIterator.hasNext()) {
		Node projectNode = nodeIterator.nextNode();
		if (!projectNode.hasProperty(FILE)) {
			continue;
		}
		String projectName = projectNode.getName();
		if (project != null && !project.equals(projectName)) {
			continue;
		}
		targetProjectNode = projectNode;
		break;
	}
	if (targetProjectNode == null) {
		throw new RuleException("Project [" + project + "] not exist.");
	}
	List<RepositoryFile> fileList = new ArrayList<RepositoryFile>();
	RepositoryFile root = new RepositoryFile();
	root.setName("根目录");
	String projectPath = targetProjectNode.getPath();
	root.setFullPath(projectPath);
	fileList.add(root);
	NodeIterator projectNodeIterator = targetProjectNode.getNodes();
	while (projectNodeIterator.hasNext()) {
		Node dirNode = projectNodeIterator.nextNode();
		if (!dirNode.hasProperty(DIR_TAG)) {
			continue;
		}
		RepositoryFile file = new RepositoryFile();
		file.setName(dirNode.getPath().substring(projectPath.length()));
		file.setFullPath(dirNode.getPath());
		fileList.add(file);
		buildDirectories(dirNode, fileList, projectPath);
	}
	return fileList;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private void generate(Node node) throws RepositoryException, IOException {
    Node originalNode = node.getNode(PATH_ORIGINAL);

    if (!originalNode.hasProperty("jcr:content/jcr:mimeType")) {
        log.warn("Ignoring [{}] as it does not defined the jcr:mimeType", originalNode.getPath());
        return;
    }

    workDir = Files.createTempDir();
    InputStream is = JcrUtils.readFile(originalNode);

    File original = copy(is, "original");
    Map<String, File> renditions = generate(original);
    copy(renditions, node.getNode("jcr:content/renditions"));
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public Repository loadRepository(String project,User user,boolean classify,FileType[] types,String searchFileName) throws Exception{
	String companyId=user.getCompanyId();
	createSecurityConfigFile(user);
	if(project!=null && project.startsWith("/")){
		project=project.substring(1,project.length());
	}
	Repository repo=new Repository();
	List<String> projectNames=new ArrayList<String>();
	repo.setProjectNames(projectNames);
	RepositoryFile rootFile = new RepositoryFile();
	rootFile.setFullPath("/");
	rootFile.setName("项目列表");
	rootFile.setType(Type.root);
	Node rootNode=getRootNode();
	NodeIterator nodeIterator = rootNode.getNodes();
	while (nodeIterator.hasNext()) {
		Node projectNode = nodeIterator.nextNode();
		if (!projectNode.hasProperty(FILE)) {
			continue;
		}
		if(StringUtils.isNotEmpty(companyId)){
			if(projectNode.hasProperty(COMPANY_ID)){
				String id=projectNode.getProperty(COMPANY_ID).getString();
				if(!companyId.equals(id)){
					continue;
				}
			}
		}
		String projectName = projectNode.getName();
		if(projectName.indexOf(RESOURCE_SECURITY_CONFIG_FILE)>-1){
			continue;
		}
		if (StringUtils.isNotBlank(project) && !project.equals(projectName)) {
			continue;
		}
		if(!permissionService.projectHasPermission(projectNode.getPath())){
			continue;
		}
		if(StringUtils.isBlank(project)){
			projectNames.add(projectName);
		}
		RepositoryFile projectFile=buildProjectFile(projectNode,types,classify,searchFileName);
		rootFile.addChild(projectFile, false);
	}
	repo.setRootFile(rootFile);
	return repo;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
@Override
public void removeArtifact( ArtifactMetadata artifactMetadata, String baseVersion )
    throws MetadataRepositoryException
{

    String repositoryId = artifactMetadata.getRepositoryId();

    try
    {
        Node root = getJcrSession().getRootNode();
        String path =
            getProjectVersionPath( repositoryId, artifactMetadata.getNamespace(), artifactMetadata.getProject(),
                                   baseVersion );

        if ( root.hasNode( path ) )
        {
            Node node = root.getNode( path );

            for ( Node n : JcrUtils.getChildNodes( node ) )
            {
                if ( n.isNodeType( ARTIFACT_NODE_TYPE ) )
                {
                    if ( n.hasProperty( "version" ) )
                    {
                        String version = n.getProperty( "version" ).getString();
                        if ( StringUtils.equals( version, artifactMetadata.getVersion() ) )
                        {
                            n.remove();
                        }
                    }

                }
            }
        }
    }
    catch ( RepositoryException e )
    {
        throw new MetadataRepositoryException( e.getMessage(), e );
    }


}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private ArtifactMetadata getArtifactFromNode( String repositoryId, Node artifactNode )
    throws RepositoryException
{
    String id = artifactNode.getName();

    ArtifactMetadata artifact = new ArtifactMetadata();
    artifact.setId( id );
    artifact.setRepositoryId( repositoryId == null ? artifactNode.getAncestor(2).getName() : repositoryId );

    Node projectVersionNode = artifactNode.getParent();
    Node projectNode = projectVersionNode.getParent();
    Node namespaceNode = projectNode.getParent();

    artifact.setNamespace( namespaceNode.getProperty( "namespace" ).getString() );
    artifact.setProject( projectNode.getName() );
    artifact.setProjectVersion( projectVersionNode.getName() );
    artifact.setVersion( artifactNode.hasProperty( "version" )
                             ? artifactNode.getProperty( "version" ).getString()
                             : projectVersionNode.getName() );

    if ( artifactNode.hasProperty( JCR_LAST_MODIFIED ) )
    {
        artifact.setFileLastModified( artifactNode.getProperty( JCR_LAST_MODIFIED ).getDate().getTimeInMillis() );
    }

    if ( artifactNode.hasProperty( "whenGathered" ) )
    {
        artifact.setWhenGathered( artifactNode.getProperty( "whenGathered" ).getDate().getTime() );
    }

    if ( artifactNode.hasProperty( "size" ) )
    {
        artifact.setSize( artifactNode.getProperty( "size" ).getLong() );
    }

    if ( artifactNode.hasProperty( "md5" ) )
    {
        artifact.setMd5( artifactNode.getProperty( "md5" ).getString() );
    }

    if ( artifactNode.hasProperty( "sha1" ) )
    {
        artifact.setSha1( artifactNode.getProperty( "sha1" ).getString() );
    }

    for ( Node n : JcrUtils.getChildNodes( artifactNode ) )
    {
        if ( n.isNodeType( FACET_NODE_TYPE ) )
        {
            String name = n.getName();
            MetadataFacetFactory factory = metadataFacetFactories.get( name );
            if ( factory == null )
            {
                log.error( "Attempted to load unknown project version metadata facet: " + name );
            }
            else
            {
                MetadataFacet facet = factory.createMetadataFacet();
                Map<String, String> map = new HashMap<>();
                for ( Property p : JcrUtils.getProperties( n ) )
                {
                    String property = p.getName();
                    if ( !property.startsWith( "jcr:" ) )
                    {
                        map.put( property, p.getString() );
                    }
                }
                facet.fromProperties( map );
                artifact.addFacet( facet );
            }
        }
    }
    return artifact;
}
 

import javax.jcr.Node; //导入方法依赖的package包/类
private static String getPropertyString( Node node, String name )
    throws RepositoryException
{
    return node.hasProperty( name ) ? node.getProperty( name ).getString() : null;
}