How to use

Property

in

javax.jcr

/**
 * Expanded names must always be resolved.
 * Test setting a NAME-value property.
 *
 * @throws RepositoryException
 */
public void testExpandedNameValueProperty() throws RepositoryException {
  ValueFactory vf = superuser.getValueFactory();
  Value nameValue = vf.createValue(Workspace.NAME_VERSION_STORAGE_NODE, PropertyType.NAME);
  Property p = testRootNode.setProperty(propertyName1, nameValue);
  assertEquals(PropertyType.NAME, p.getType());
  assertEquals(nameValue.getString(), p.getValue().getString());
  assertEquals(nameValue, p.getValue());
  assertEquals("jcr:versionStorage", p.getString());
}

@Override
public NodeType[] getMixinNodeTypes() throws RepositoryException {
  Value[] vals = this.node.getProperty("jcr:frozenMixinTypes").getValues();
  NodeTypeManager typeMan = getJCRNode().getSession().getWorkspace().getNodeTypeManager();
  NodeType[] types = new NodeType[vals.length];
  int i = 0;
  for (Value val : vals) {
    types[i++] = typeMan.getNodeType(val.getString());
  }
  return types;
}

private void appendNodeProperties(Node node, Properties out) throws RepositoryException {
  PropertyIterator propertyIterator = node.getProperties();
  while (propertyIterator.hasNext()) {
    Property property = propertyIterator.nextProperty();
    String path = getExportPath(node) + "." + property.getName();
    String propertyValue = getPropertyString(property);
    if (propertyValue != null) {
      out.setProperty(path, propertyValue);
    }
  }
}

public static void moveProperty(Property source, Node targetNode) throws RepositoryException {
  // JCR props can't be moved, we gotta recreate w/ same value and delete
  if (source.isMultiple()) {
    targetNode.setProperty(source.getName(), source.getValues());
  } else {
    targetNode.setProperty(source.getName(), source.getValue());
  }
  source.remove();
}

/**
 * Move <code>property</code> to the new <code>parent</code>.
 */
protected void move(Property property, Node parent) throws RepositoryException {
  parent.setProperty(property.getName(), property.getValue());
  property.remove();
}

private Value[] getPropertyValues(PropertyValue operand, Node node)
    throws RepositoryException {
  Property property = getProperty(operand, node);
  if (property == null) {
    return new Value[0];
  } else if (property.isMultiple()) {
    return property.getValues();
  } else {
    return new Value[] { property.getValue() };
  }
}

public void testVersionReferencesV1() throws RepositoryException {
  Node n = testRootNode.addNode(nodeName1, testNodeType);
  n.addMixin(mixVersionable);
  superuser.save();
  String p = n.getPath();
  VersionManager vMgr = superuser.getWorkspace().getVersionManager();
  Version v1 = vMgr.checkpoint(p);
  // check if versionable node has references to v1.0
  assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_BASE_VERSION).getString());
  assertEquals("v1.0", v1.getIdentifier(), n.getProperty(Property.JCR_PREDECESSORS).getValues()[0].getString());
  checkReferences("v1.0", v1.getReferences(),
      p + "/jcr:baseVersion",
      p + "/jcr:predecessors"
  );
}

/**
 * @throws RepositoryException
 */
public void testFrozenNodeType() throws RepositoryException {
  VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
  String path = versionableNode.getPath();
  Version v = versionManager.checkin(path);
  Node n = v.getFrozenNode();
  String fuuid = n.getProperty("jcr:frozenPrimaryType").getValue().getString();
  String ruuid = versionableNode.getPrimaryNodeType().getName();
  assertEquals("jcr:frozenPrimaryType needs to be equal to the getPrimaryNodeType() return value.", ruuid, fuuid);
}

public void testVersionablePathsAfterRename() throws Exception {
  Node node1 = testRootNode.addNode(nodeName1);
  node1.addMixin(JcrConstants.MIX_VERSIONABLE);
  superuser.save();
  String destPath = testRoot + "/" + nodeName2;
  superuser.move(node1.getPath(), destPath);
  superuser.save();
  Node vh = getVersionManager().getVersionHistory(node1.getPath());
  assertTrue(vh.isNodeType("rep:VersionablePaths"));
  String workspaceName = superuser.getWorkspace().getName();
  assertTrue(vh.hasProperty(workspaceName));
  assertEquals(node1.getPath(), vh.getProperty(workspaceName).getString());
}

public void testMoveJson() throws Exception {
  Node test = createJsonNode("test.json");
  test.getSession().getWorkspace().move(test.getPath(), test.getParent().getPath() + "/target.json");
  Session s = getHelper().getReadOnlySession();
  try {
    Property p = s.getNode(testRoot).getNode("target.json").getNode(JcrConstants.JCR_CONTENT)
        .getProperty(JcrConstants.JCR_DATA);
    assertEquals(jsondata, IOUtils.toString(p.getBinary().getStream(), "UTF-8"));
  } finally {
    s.logout();
  }
}

public void testMultiValues() throws Exception {
  superuser.importXML(targetPath, getImportStream(), ImportUUIDBehavior.IMPORT_UUID_CREATE_NEW);
  superuser.save();
  Node n = superuser.getNode(targetPath).getNode(nodeName4);
  Property p = n.getNode(nodeName2).getProperty("test:multiProperty");
  assertTrue(p.isMultiple());
  assertTrue(p.getDefinition().isMultiple());
  Value[] expected = new Value[] {vf.createValue("v1"), vf.createValue("v2")};
  Assert.assertArrayEquals(expected, p.getValues());
}

/**
 * @throws RepositoryException
 */
public void testFrozenNodeUUUID() throws RepositoryException {
  VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
  String path = versionableNode.getPath();
  Version v = versionManager.checkin(path);
  Node n = v.getFrozenNode();
  String puuid = n.getProperty(jcrUUID).getValue().getString();
  String nuuid = n.getIdentifier();
  assertEquals("jcr:uuid needs to be equal to the getIdentifier() return value.", nuuid, puuid);
}

@Test
public void setPropertyStringValueArrayInt() throws RepositoryException {
  // GIVEN
  Node node = MgnlContext.getJCRSession("website").getRootNode().addNode("test", MgnlNodeType.NT_CONTENT);
  assertTrue(NodeUtil.isWrappedWith(node, MgnlAuditLoggingContentDecoratorNodeWrapper.class));
  Value[] values = {ValueFactoryImpl.getInstance().createValue("true")};
  // WHEN
  node.setProperty("test", values, PropertyType.BOOLEAN);
  // THEN
  assertEquals(PropertyType.BOOLEAN, node.getProperty("test").getType());
}

@Test
public void getReferences() throws RepositoryException {
  Session session = getAdminSession();
  Node referee = getNode("/foo");
  referee.addMixin("mix:referenceable");
  getNode(TEST_PATH).setProperty("reference", session.getValueFactory().createValue(referee));
  session.save();
  PropertyIterator refs = referee.getReferences();
  assertTrue(refs.hasNext());
  Property p = refs.nextProperty();
  assertEquals("reference", p.getName());
  assertFalse(refs.hasNext());
}

/**
 * Test if versionable node N's jcr:baseVersion property is set to refer to
 * the new version after checkin.
 *
 * @throws RepositoryException
 */
public void testBaseVersionAfterCheckinJcr2() throws RepositoryException {
  VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
  String path = versionableNode.getPath();
  Version v = versionManager.checkin(path);
  Value baseVersionRef = versionableNode.getProperty(jcrBaseVersion).getValue();
  assertEquals("Checked-in node's jcr:baseVersion property is set to refer to the version created on checkin.", superuser.getValueFactory().createValue(v), baseVersionRef);
}

public void testGetTypeOfPredecessors() throws RepositoryException {
  Node node = testRootNode.addNode(nodeName1, testNodeType);
  node.addMixin(mixVersionable);
  superuser.save();
  VersionManager vMgr = superuser.getWorkspace().getVersionManager();
  vMgr.checkin(node.getPath());
  assertEquals(PropertyType.nameFromValue(PropertyType.REFERENCE),
      PropertyType.nameFromValue(node.getProperty(jcrPredecessors).getType()));
}

@Override
public void runTest() throws Exception {
  Node node = session.getRootNode().getNode(ROOT_NODE_NAME);
  for (int i = 1; i < CHILD_COUNT; i++) {
    node.getNode("node" + i).setProperty("foo", "bar");
    session.save();
    node.getNode("node" + i).getProperty("foo").remove();
    node.getNode("node0").setProperty("foo", i);
    session.save();
  }
}

private InputStream storeBinaryProperty( byte[] data,
                     String nodeName ) throws RepositoryException {
  Node testRoot = jcrSession().getRootNode().addNode(nodeName);
  testRoot.setProperty("binary", session.getValueFactory().createValue(new ByteArrayInputStream(data)));
  jcrSession().save();
  Property binary = jcrSession().getNode("/" + nodeName).getProperty("binary");
  Assert.assertNotNull(binary);
  return binary.getBinary().getStream();
}

static NodeIterator executeQuery(final Session session, final Node templateQueryNode) throws RepositoryException {
  final String statement = templateQueryNode.getProperty("jcr:statement").getString();
  final String language =  templateQueryNode.getProperty("jcr:language").getString();
  final QueryManager queryManager = session.getWorkspace().getQueryManager();
  final Query query = queryManager.createQuery(statement, language);
  final QueryResult queryResult = query.execute();
  return queryResult.getNodes();
}

@MgnlDeprecated(since = "5.6.2", description = "No need to call since #addComment should not be called.")
@Deprecated
protected void cleanComment(final Node node) throws RepositoryException {
  synchronized (ExclusiveWrite.getInstance()) {
    if (node.hasProperty(NodeTypes.Versionable.COMMENT)
        && !StringUtils.EMPTY.equals(node.getProperty(NodeTypes.Versionable.COMMENT).getString())) {
      node.getProperty(NodeTypes.Versionable.COMMENT).remove();
      node.getSession().save();
    }
  }
}