Java JcrTools类代码示例

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see Modelspace#importData(InputStream, String)
 */
@Override
public String importData( final InputStream stream,
                          final String workspacePath ) throws ModelspaceException {
    CheckArg.isNotNull( stream, "stream" );
    CheckArg.isNotEmpty( workspacePath, "workspacePath" );
    return run( new WriteTaskWithResult< String >() {

        @Override
        public String run( final Session session ) throws Exception {
            // Ensure the path is non-null, absolute, and ends with a slash
            final Node node = new JcrTools().uploadFile( session, absolutePath( workspacePath ), stream );
            // Add unstructured mix-in to allow node to contain anything else, like models created later
            node.addMixin( ModelspaceLexicon.UNSTRUCTURED_MIXIN );
            return node.getPath();
        }
    } );
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldSkolemizeBlankNodeSubjects() throws RepositoryException {
    final Model m = createDefaultModel();
    final Resource resource = createResource();
    final Statement x = m.createStatement(resource,
            createProperty("info:x"),
            testSubjects.toDomain("/"));
    testObj.jcrTools = mock(JcrTools.class);
    when(testObj.jcrTools.findOrCreateNode(eq(mockSession), anyString(), eq(NT_FOLDER))).thenReturn(mockNode);
    when(mockNode.getPath()).thenReturn("/#/x");
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockHashNode.isNew()).thenReturn(true);
    when(FedoraTypesUtils.getClosestExistingAncestor(mockSession, anyString())).thenReturn(mockHashNode);
    final Statement statement = testObj.skolemize(testSubjects, x, "info:fedora/");

    assertTrue("Doesn't match: " + statement.getSubject().toString(),
            statement.getSubject().toString().startsWith("info:fedora/#"));
    verify(mockNode).addMixin(FEDORA_RESOURCE);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldSkolemizeBlankNodeObjects() throws RepositoryException {
    final Model m = createDefaultModel();
    final Statement x = m.createStatement(testSubjects.toDomain("/foo"),
            createProperty("info:x"),
            createResource());
    testObj.jcrTools = mock(JcrTools.class);
    when(testObj.jcrTools.findOrCreateNode(eq(mockSession), anyString(), eq(NT_FOLDER))).thenReturn(mockNode);
    when(mockNode.getPath()).thenReturn("/foo#abc");
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockHashNode.isNew()).thenReturn(true);
    when(FedoraTypesUtils.getClosestExistingAncestor(mockSession, anyString())).thenReturn(mockHashNode);
    final Statement statement = testObj.skolemize(testSubjects, x, x.getSubject().toString());

    assertTrue(statement.getObject().toString().startsWith("info:fedora/foo#"));
    verify(mockNode).addMixin(FEDORA_RESOURCE);
    verify(mockNode.getParent()).addMixin(FEDORA_PAIRTREE);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldSkolemizeBlankNodeSubjectsAndObjects() throws RepositoryException {
    final Model m = createDefaultModel();
    final Resource resource = createResource();
    final Statement x = m.createStatement(resource,
            createProperty("info:x"),
            resource);
    testObj.jcrTools = mock(JcrTools.class);
    when(testObj.jcrTools.findOrCreateNode(eq(mockSession), anyString(), eq(NT_FOLDER))).thenReturn(mockNode);
    when(mockNode.getPath()).thenReturn("/#/x");
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(FedoraTypesUtils.getClosestExistingAncestor(mockSession, anyString())).thenReturn(mockHashNode);
    final Statement statement = testObj.skolemize(testSubjects, x, "info:fedora/");

    assertTrue(statement.getSubject().toString().startsWith("info:fedora/#"));
    assertTrue(statement.getObject().toString().startsWith("info:fedora/#"));
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldCreateHashUriSubjects() throws RepositoryException {
    final Model m = createDefaultModel();
    final Statement x = m.createStatement(testSubjects.toDomain("/some/#/abc"),
            createProperty("info:x"),
            testSubjects.toDomain("/"));
    testObj.jcrTools = mock(JcrTools.class);
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockSession.nodeExists("/some")).thenReturn(true);
    when(mockSession.getNode("/some")).thenReturn(mockChildNode);
    when(mockChildNode.isNew()).thenReturn(false);
    when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER)).thenReturn(mockNode);
    when(mockHashNode.isNew()).thenReturn(true);
    final Statement statement = testObj.skolemize(testSubjects, x, "/some/#/abc");
    assertEquals(x, statement);
    verify(testObj.jcrTools).findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER);
    verify(mockNode).addMixin(FEDORA_RESOURCE);
    verify(mockHashNode).addMixin(FEDORA_PAIRTREE);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldCreateHashUriSubjectsWithExistingHashUri() throws RepositoryException {
    final Model m = createDefaultModel();
    final Statement x = m.createStatement(testSubjects.toDomain("/some/#/abc"),
            createProperty("info:x"),
            testSubjects.toDomain("/"));
    testObj.jcrTools = mock(JcrTools.class);
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockSession.nodeExists("/some")).thenReturn(true);
    when(mockSession.getNode("/some")).thenReturn(mockChildNode);
    when(mockChildNode.isNew()).thenReturn(false);
    when(mockChildNode.hasNode("#")).thenReturn(true);
    when(mockChildNode.getNode("#")).thenReturn(mockHashNode);
    when(mockHashNode.isNew()).thenReturn(false);
    when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER)).thenReturn(mockNode);
    final Statement statement = testObj.skolemize(testSubjects, x, "/some/#/abc");
    assertEquals(x, statement);
    verify(testObj.jcrTools).findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER);
    verify(mockNode).addMixin(FEDORA_RESOURCE);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void shouldCreateHashUriObjects() throws RepositoryException {
    final Model m = createDefaultModel();
    final Statement x = m.createStatement(
            testSubjects.toDomain("/"),
            createProperty("info:x"),
            testSubjects.toDomain("/some/#/abc"));
    testObj.jcrTools = mock(JcrTools.class);
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockSession.nodeExists("/some")).thenReturn(true);
    when(mockSession.getNode("/some")).thenReturn(mockChildNode);
    when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER)).thenReturn(mockNode);
    final Statement statement = testObj.skolemize(testSubjects, x, "/");
    assertEquals(x, statement);
    verify(testObj.jcrTools).findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER);
    verify(mockNode).addMixin(FEDORA_RESOURCE);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see org.modelspace.ModelObject#print()
 */
@Override
public void print() throws ModelspaceException {
    modelspace.run( new Task() {

        @Override
        public void run( final Session session ) throws Exception {
            final JcrTools tools = new JcrTools();
            tools.setDebug( true );
            tools.printSubgraph( session.getNode( path ) );
        }
    } );
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see org.modelspace.spi.DependencyProcessor#process(java.lang.String, javax.jcr.Node,
 *      org.modelspace.Modelspace, boolean)
 */
@Override
public String process( final String dataPath,
                       final Node modelNode,
                       final Modelspace modelspace,
                       final boolean persistArtifacts ) throws ModelspaceException {
    try {
        new JcrTools().printSubgraph( modelNode );
        return null;
    } catch ( final RepositoryException e ) {
        throw new ModelspaceException( e, "Unable to resolve dependencies for \"%s\"", modelNode );
    }
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test
public void contentEventCollapsing() throws RepositoryException, InvalidChecksumException {

    final FedoraSession session = repository.login();
    final Session se = getJcrSession(session);
    final JcrTools jcrTools = new JcrTools();

    final Node n = jcrTools.findOrCreateNode(se.getRootNode(), "/object3", NT_FOLDER, NT_FILE);
    n.addMixin(FEDORA_RESOURCE);

    final String content = "test content";
    final String checksum = "1eebdf4fdc9fc7bf283031b93f9aef3338de9052";
    ((ValueFactory) se.getValueFactory()).createBinary(new ByteArrayInputStream(content.getBytes()), null);

    final Node contentNode = jcrTools.findOrCreateChild(n, JCR_CONTENT, NT_RESOURCE);
    contentNode.addMixin(FEDORA_BINARY);
    final FedoraBinary binary = new FedoraBinaryImpl(contentNode);
    binary.setContent( new ByteArrayInputStream(content.getBytes()), "text/plain",
            new HashSet<>(asList(asURI(SHA1.algorithm, checksum))), "text.txt", null);

    try {
        session.commit();
    } finally {
        session.expire();
    }

    awaitEvent("/object3", RESOURCE_CREATION, REPOSITORY_NAMESPACE + "Binary");

    assertEquals("Node and content events not collapsed!", (Integer) 1, eventBusMessageCount);
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
@Test(expected = PathNotFoundException.class)
public void shouldNotAllowHashUriSubjectsForResourcesThatDontExist() throws RepositoryException {
    final Model m = createDefaultModel();
    final Statement x = m.createStatement(testSubjects.toDomain("/some/#/abc"),
            createProperty("info:x"),
            testSubjects.toDomain("/"));
    testObj.jcrTools = mock(JcrTools.class);
    when(mockNode.getParent()).thenReturn(mockHashNode);
    when(mockHashNode.getParent()).thenReturn(mockChildNode);
    when(mockSession.nodeExists("/some")).thenReturn(false);
    when(testObj.jcrTools.findOrCreateNode(mockSession, "/some/#/abc", NT_FOLDER)).thenReturn(mockNode);
    when(FedoraTypesUtils.getClosestExistingAncestor(mockSession,"/some/#/abc"))
            .thenReturn(mockNode);
    testObj.skolemize(testSubjects, x, "/some");
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
private JcrTools getJcrTools() {
    if (null == jcrTools) {
        this.jcrTools = new JcrTools(true);
    }
    return jcrTools;
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * Only for UNIT TESTING
 * @param jcrTools
 */
@VisibleForTesting
public void setJcrTools(final JcrTools jcrTools) {
    this.jcrTools = jcrTools;
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * @param dataPath
 *        the workspace path to the data
 * @param modelPath
 *        the workspace path to the model
 * @param metamodel
 *        the model's metamodel
 * @param persistArtifact
 *        <code>true</code> if the data should be persisted after import
 * @return the model
 * @throws ModelspaceException
 *         if an error occurs
 */
public Model generateModel( final String dataPath,
                            final String modelPath,
                            final Metamodel metamodel,
                            final boolean persistArtifact ) throws ModelspaceException {
    CheckArg.isNotEmpty( dataPath, "dataPath" );
    CheckArg.isNotEmpty( modelPath, "modelPath" );

    try {
        return run( new WriteTaskWithResult< Model >() {

            @Override
            public Model run( final Session session ) throws Exception {
                final Node dataNode = dataNode( session, dataPath );
                Metamodel actualMetamodel = metamodel;
                if ( actualMetamodel == null ) {
                    // If no metamodel supplied, use default metamodel if one exists
                    final MetamodelManagerImpl manager = ( MetamodelManagerImpl ) metamodelManager();
                    actualMetamodel = manager.defaultMetamodel( dataNode, manager.metamodels( dataNode ) );
                    if ( actualMetamodel == null )
                        throw new IllegalArgumentException( ModelspaceI18n.localize( "Unable to determine default metamodel for file %s",
                                                                                  dataPath ) );
                    throw new UnsupportedOperationException( "Not yet implemented" );
                }
                // Build the model
                final ValueFactory valueFactory = ( ValueFactory ) session.getValueFactory();
                final Calendar cal = Calendar.getInstance();
                final Node modelNode = new JcrTools().findOrCreateNode( session, absolutePath( modelPath ) );
                modelNode.addMixin( ModelspaceLexicon.Model.MODEL_MIXIN );
                if ( dataNode.hasProperty( ModelspaceLexicon.Model.EXTERNAL_LOCATION ) )
                    modelNode.setProperty( ModelspaceLexicon.Model.EXTERNAL_LOCATION,
                                           dataNode.getProperty( ModelspaceLexicon.Model.EXTERNAL_LOCATION ).getString() );
                final SequencerImporter importer = ( SequencerImporter ) actualMetamodel.importer();
                final boolean save = importer.execute( dataNode.getNode( JcrLexicon.CONTENT.getString() )
                                                               .getProperty( JcrLexicon.DATA.getString() ),
                                                       modelNode,
                                                       new Sequencer.Context() {

                                                           @Override
                                                           public Calendar getTimestamp() {
                                                               return cal;
                                                           }

                                                           @Override
                                                           public ValueFactory valueFactory() {
                                                               return valueFactory;
                                                           }
                                                       } );

                if ( save ) {
                    modelNode.setProperty( ModelspaceLexicon.Model.METAMODEL, actualMetamodel.id() );
                    final ModelImpl model = new ModelImpl( ModelspaceImpl.this, modelNode.getPath() );
                    session.save();
                    processDependencies( dataPath, modelNode, model, persistArtifact );
                    return model;
                }

                throw new ModelspaceException( "Unable to create %s model \"%s\" from data at \"%s\"",
                                            actualMetamodel.name(), modelPath, dataPath );
            }
        } );
    } finally {
        if ( !persistArtifact ) {
            removeTemporaryArtifact( dataPath );
        }
    }
}
 

import org.modeshape.jcr.api.JcrTools; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see org.modelspace.Modelspace#newModel(java.lang.String, java.lang.String, boolean)
 */
@Override
public Model newModel( final String modelPath,
                       final String metamodelId,
                       final boolean override ) throws ModelspaceException {
    CheckArg.isNotEmpty( modelPath, "modelPath" );
    CheckArg.isNotEmpty( metamodelId, "metamodelId" );

    return run( new TaskWithResult< Model >() {

        /**
         * {@inheritDoc}
         * 
         * @see org.modelspace.internal.task.TaskWithResult#run(javax.jcr.Session)
         */
        @Override
        public Model run( final Session session ) throws Exception {
            boolean create = true;
            final String absPath = absolutePath( modelPath );

            if ( session.nodeExists( absPath ) ) {
                if ( override ) {
                    // delete
                    session.getNode( absPath ).remove();
                } else {
                    final Node node = session.getNode( absPath );

                    // make sure it is a model with the right metamodel ID
                    if ( !node.isNodeType( ModelspaceLexicon.Model.MODEL_MIXIN )
                         || !node.hasProperty( ModelspaceLexicon.Model.METAMODEL )
                         || !metamodelId.equals( node.getProperty( ModelspaceLexicon.Model.METAMODEL ).getValue().getString() ) ) {
                        throw new ModelspaceException( ModelspaceI18n.localize( EXISTING_MODEL_HAS_WRONG_METAMODEL_TYPE,
                                                                          absPath,
                                                                          metamodelId ) );
                    }

                    create = false;
                }
            }

            if ( create ) {
                final Node modelNode = new JcrTools().findOrCreateNode( session, absPath );
                modelNode.addMixin( ModelspaceLexicon.Model.MODEL_MIXIN );
                modelNode.setProperty( ModelspaceLexicon.Model.METAMODEL, metamodelId );
            }

            return new ModelImpl( ModelspaceImpl.this, absPath );
        }
    } );
}