@FixFor("MODE-1732")
@Test
public void shouldFollowReferenceFromRecentTagToCommit() throws Exception {
Node git = gitNode();
Node tag = git.getNode("tags/modeshape-3.0.0.Final");
assertThat(tag.getProperty("git:objectId").getString(), is(notNullValue()));
assertThat(tag.getProperty("git:tree").getString(), is(notNullValue()));
assertThat(tag.getProperty("git:history").getString(), is(notNullValue()));
Node tagTree = tag.getProperty("git:tree").getNode();
assertThat(tagTree.getPath(), is(treePathFor(tag)));
assertChildrenInclude(tagTree, expectedTopLevelFileAndFolderNames());
// Load some of the child nodes ...
Node pomFile = tagTree.getNode("pom.xml");
assertThat(pomFile.getPrimaryNodeType().getName(), is("git:file"));
assertNodeHasObjectIdProperty(pomFile);
assertNodeHasCommittedProperties(pomFile);
Node pomContent = pomFile.getNode("jcr:content");
assertNodeHasCommittedProperties(pomContent);
assertThat(pomContent.getProperty("jcr:data").getString(), is(notNullValue()));
Node readmeFile = tagTree.getNode("README.md");
assertThat(readmeFile.getPrimaryNodeType().getName(), is("git:file"));
assertNodeHasObjectIdProperty(readmeFile);
assertNodeHasCommittedProperties(readmeFile);
Node readmeContent = readmeFile.getNode("jcr:content");
assertNodeHasCommittedProperties(readmeContent);
assertThat(readmeContent.getProperty("jcr:data").getString(), is(notNullValue()));
Node parentModule = tagTree.getNode("modeshape-parent");
assertThat(parentModule.getPrimaryNodeType().getName(), is("git:folder"));
assertNodeHasObjectIdProperty(parentModule);
assertNodeHasCommittedProperties(parentModule);
}
public String[] getFileNames(long companyId, long repositoryId) throws SystemException {
List<String> fileNames = new ArrayList<String>();
Session session = null;
try {
session = JCRFactoryUtil.createSession();
Node rootNode = getRootNode(session, companyId);
Node repositoryNode = getFolderNode(rootNode, repositoryId);
NodeIterator itr = repositoryNode.getNodes();
while (itr.hasNext()) {
Node node = (Node) itr.next();
NodeType primaryNodeType = node.getPrimaryNodeType();
String primaryNodeTypeName = primaryNodeType.getName();
if (primaryNodeTypeName.equals(JCRConstants.NT_FILE)) {
fileNames.add(node.getName());
}
}
} catch (Exception e) {
throw new SystemException(e);
} finally {
JCRFactoryUtil.closeSession(session);
}
return fileNames.toArray(new String[0]);
}
@Override
public List<JcrNode> childNodes(String path) throws RemoteException {
List<JcrNode> children = null;
if (path == null || path.trim().length() == 0) {
return Collections.emptyList();
}
try {
Node node = (Node) session().getItem(path);
NodeIterator it = node.getNodes();
children = new ArrayList<JcrNode>((int) it.getSize());
while (it.hasNext()) {
Node n = it.nextNode();
JcrNode childNode = new JcrNode(n.getName(), n.getPath(), n.getPrimaryNodeType().getName());
childNode.setProperties(getProperties(n));
childNode.setAcessControlList(getAccessList(session().getAccessControlManager(), node));
childNode.setMixins(mixins(n));
childNode.setPropertyDefs(propertyDefs(n));
children.add(childNode);
}
} catch (PathNotFoundException e) {
log.log(Level.FINER, e.getLocalizedMessage());
} catch (RepositoryException e) {
log.log(Level.SEVERE, "Unexpected error", e);
throw new RemoteException(e.getMessage());
}
return children;
}
/**
* Gets the list of properties available to the given node.
*
* @param node the node instance.
* @return list of property names.
* @throws RepositoryException
*/
private String[] propertyDefs(Node node) throws RepositoryException {
ArrayList<String> list = new ArrayList();
NodeType primaryType = node.getPrimaryNodeType();
PropertyDefinition[] defs = primaryType.getPropertyDefinitions();
for (PropertyDefinition def : defs) {
if (!def.isProtected()) {
list.add(def.getName());
}
}
NodeType[] mixinType = node.getMixinNodeTypes();
for (NodeType type : mixinType) {
defs = type.getPropertyDefinitions();
for (PropertyDefinition def : defs) {
if (!def.isProtected()) {
list.add(def.getName());
}
}
}
String[] res = new String[list.size()];
list.toArray(res);
return res;
}
@Before
public void setUp() throws RepositoryException {
initMocks(this);
final String relPath = "/" + testPid;
final NodeType[] types = new NodeType[0];
try {
when(mockObjNode.getName()).thenReturn(testPid);
when(mockObjNode.getSession()).thenReturn(mockSession);
when(mockObjNode.getMixinNodeTypes()).thenReturn(types);
NodeType mockNodeType = mock(NodeType.class);
when(mockNodeType.getName()).thenReturn("nt:folder");
when(mockObjNode.getPrimaryNodeType()).thenReturn(mockNodeType);
when(mockSession.getRootNode()).thenReturn(mockRootNode);
when(mockRootNode.getNode(relPath)).thenReturn(mockObjNode);
when(mockSession.getUserID()).thenReturn(mockUser);
testFedoraObject = new FedoraObject(mockObjNode);
mockNodetypes = new NodeType[2];
mockNodetypes[0] = mock(NodeType.class);
mockNodetypes[1] = mock(NodeType.class);
when(mockObjNode.getMixinNodeTypes()).thenReturn(mockNodetypes);
when(mockPredicate.apply(mockObjNode)).thenReturn(true);
} catch (final RepositoryException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
/** A LockException is thrown if a lock prevents the copy. */
public void testMoveNodesLocked() throws RepositoryException {
// we assume repository supports locking
String dstAbsPath = node2.getPath() + "/" + node1.getName();
// get other session
Session otherSession = helper.getReadWriteSession();
try {
// get lock target node in destination wsp through other session
Node lockTarget = (Node) otherSession.getItem(node2.getPath());
// add mixin "lockable" to be able to lock the node
if (!lockTarget.getPrimaryNodeType().isNodeType(mixLockable)) {
lockTarget.addMixin(mixLockable);
lockTarget.getParent().save();
}
// lock dst parent node using other session
lockTarget.lock(true, true);
try {
workspace.move(node1.getPath(), dstAbsPath);
fail("LockException was expected.");
} catch (LockException e) {
// successful
} finally {
lockTarget.unlock();
}
} finally {
otherSession.logout();
}
}
private String getType(Node node) throws Exception {
if (node.isNodeType("exo:taxonomy")) {
return "category";
} else if (documentTypes.contains(node.getPrimaryNodeType().getName())) {
return "article";
}
return "";
}
@Override
public boolean matchesSafely(Node item) {
try {
return item != null && item.getPrimaryNodeType().getName().equals(primaryType);
} catch (RepositoryException e) {
return false;
}
}
@Test
public void shouldContainTagsAndBranchNamesAndCommitsUnderTreeNode() throws Exception {
Node git = gitNode();
Node tree = git.getNode("tree");
assertThat(tree.getPrimaryNodeType().getName(), is("git:trees"));
assertChildrenInclude(tree, expectedBranchNames());
assertChildrenInclude("Make sure you run <git fetch --tags>", tree, expectedTagNames());
}
/**
* Create a link to a file. There is no need to call a session.save, the change is persistent.
*
* @param fileNode The node that represents the file. This node has to be retrieved via the normal
* user his {@link Session session}. If the userID equals {@link UserConstants.ANON_USERID} an
* AccessDeniedException will be thrown.
* @param linkPath The absolute path in JCR where the link should be placed.
* @param slingRepository The {@link SlingRepository} to use to login as an administrative.
* @return The newly created node.
* @throws AccessDeniedException When the user is anonymous.
* @throws RepositoryException Something else went wrong.
*/
public static boolean createLink(Node fileNode, String linkPath, SlingRepository slingRepository)
throws AccessDeniedException, RepositoryException {
Session session = fileNode.getSession();
String userId = session.getUserID();
if (UserConstants.ANON_USERID.equals(userId)) {
throw new AccessDeniedException();
}
boolean hasMixin =
JcrUtils.hasMixin(fileNode, REQUIRED_MIXIN) && fileNode.canAddMixin(REQUIRED_MIXIN);
// If the fileNode doesn't have the required referenceable mixin, we need to set it.
if (!hasMixin) {
// The required mixin is not on the node.
// Set it.
Session adminSession = null;
try {
adminSession = slingRepository.loginAdministrative(null);
// Grab the node via the adminSession
String path = fileNode.getPath();
Node adminFileNode = (Node) adminSession.getItem(path);
if (!hasMixin) {
adminFileNode.addMixin(REQUIRED_MIXIN);
}
if (adminSession.hasPendingChanges()) {
adminSession.save();
}
} finally {
if (adminSession != null) {
adminSession.logout();
}
}
}
// Now that the file is referenceable, it has a uuid.
// Use it for the link.
// Grab the (updated) node via the user's session id.
fileNode = (Node) session.getItem(fileNode.getPath());
// Create the link
Node linkNode = JcrUtils.deepGetOrCreateNode(session, linkPath);
if (!"sling:Folder".equals(linkNode.getPrimaryNodeType().getName())) {
// sling folder allows single and multiple properties, no need for the mixin.
if (linkNode.canAddMixin(REQUIRED_MIXIN)) {
linkNode.addMixin(REQUIRED_MIXIN);
}
}
linkNode.setProperty(JcrResourceConstants.SLING_RESOURCE_TYPE_PROPERTY, RT_SAKAI_LINK);
linkNode.setProperty(SAKAI_LINK, fileNode.getIdentifier());
// Save link.
if (session.hasPendingChanges()) {
session.save();
}
return true;
}
@Override
protected void describeMismatchSafely(Node item, Description mismatchDescription) {
try {
mismatchDescription
.appendText("was node with primary type ")
.appendValue(item.getPrimaryNodeType().getName());
} catch (RepositoryException e) {
super.describeMismatchSafely(item, mismatchDescription);
}
}
private boolean getIsOrderable(Resource resource) {
Node node = resource.adaptTo(Node.class);
if (node != null) {
try {
return node.getPrimaryNodeType().hasOrderableChildNodes();
} catch (RepositoryException re) {
// Ignored
}
}
return false;
}
/** @throws RepositoryException */
public void testFrozenNodeNodeType() 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(jcrPrimaryType).getValue().getString();
String nuuid = n.getPrimaryNodeType().getName();
assertEquals(
"jcr:primaryType needs to be equal to the getPrimaryNodeType() return value.",
nuuid,
puuid);
}
private String getTypeFromPath(String workspace, String path, SessionProvider sessionProvider)
throws Exception {
ManageableRepository manageableRepository = repositoryService.getCurrentRepository();
Session session = sessionProvider.getSession(workspace, manageableRepository);
Node currentFolder = null;
try {
Node node = (Node) session.getItem(path);
return node.getPrimaryNodeType().getName();
} catch (PathNotFoundException pne) {
return null;
}
}
/**
* Get the MimeType
*
* @param node the node
* @return the MimeType
*/
public static String getMimeType(Node node) {
try {
if (node.getPrimaryNodeType().getName().equals(NodetypeConstant.NT_FILE)) {
if (node.hasNode(NodetypeConstant.JCR_CONTENT))
return node.getNode(NodetypeConstant.JCR_CONTENT)
.getProperty(NodetypeConstant.JCR_MIME_TYPE)
.getString();
}
} catch (RepositoryException e) {
LOG.error(e.getMessage(), e);
}
return "";
}
/**
* This method will get all node types of node.
*
* @param node
* @return
* @throws Exception
*/
private List<String> getDocumentNodeTypes(Node node) throws Exception {
List<String> nodeTypeNameList = new ArrayList<String>();
NodeType primaryType = node.getPrimaryNodeType();
if (templateService_.isManagedNodeType(primaryType.getName())) {
nodeTypeNameList.add(primaryType.getName());
}
for (NodeType nodeType : node.getMixinNodeTypes()) {
if (templateService_.isManagedNodeType(nodeType.getName())) {
nodeTypeNameList.add(nodeType.getName());
}
}
return nodeTypeNameList;
}
/** @throws RepositoryException */
public void testFrozenChildNodeType() throws RepositoryException {
Node n1 = versionableNode.addNode("child");
versionableNode.getSession().save();
VersionManager versionManager = versionableNode.getSession().getWorkspace().getVersionManager();
String path = versionableNode.getPath();
Version v = versionManager.checkin(path);
Node n = v.getFrozenNode().getNode("child");
String fuuid = n.getProperty("jcr:frozenPrimaryType").getValue().getString();
String ruuid = n1.getPrimaryNodeType().getName();
assertEquals(
"jcr:frozenPrimaryType needs to be equal to the getPrimaryNodeType() return value.",
ruuid,
fuuid);
}
/**
* Pull a node-type specific transform out of JCR
*
* @param node
* @param key
* @return node-type specific transform
* @throws RepositoryException
*/
public static LDPathTransform getNodeTypeTransform(final Node node, final String key)
throws RepositoryException {
final Node programNode = node.getSession().getNode(CONFIGURATION_FOLDER + key);
LOGGER.debug("Found program node: {}", programNode.getPath());
final NodeType primaryNodeType = node.getPrimaryNodeType();
final Set<NodeType> supertypes =
orderedBy(nodeTypeComp).add(primaryNodeType.getSupertypes()).build();
final Set<NodeType> mixinTypes = orderedBy(nodeTypeComp).add(node.getMixinNodeTypes()).build();
// start with mixins, primary type, and supertypes of primary type
final ImmutableList.Builder<NodeType> nodeTypesB =
new ImmutableList.Builder<NodeType>()
.addAll(mixinTypes)
.add(primaryNodeType)
.addAll(supertypes);
// add supertypes of mixins
for (final NodeType mixin : mixinTypes) {
nodeTypesB.addAll(orderedBy(nodeTypeComp).add(mixin.getDeclaredSupertypes()).build());
}
final List<NodeType> nodeTypes = nodeTypesB.build();
LOGGER.debug("Discovered node types: {}", nodeTypes);
for (final NodeType nodeType : nodeTypes) {
if (programNode.hasNode(nodeType.toString())) {
return new LDPathTransform(
programNode
.getNode(nodeType.toString())
.getNode(JCR_CONTENT)
.getProperty(JCR_DATA)
.getBinary()
.getStream());
}
}
throw new WebApplicationException(
new Exception(
"Couldn't find transformation for "
+ node.getPath()
+ " and transformation key "
+ key),
SC_BAD_REQUEST);
}
public static List<String> getListAllowedFileType(
Node currentNode, TemplateService templateService) throws Exception {
List<String> nodeTypes = new ArrayList<String>();
NodeTypeManager ntManager = currentNode.getSession().getWorkspace().getNodeTypeManager();
NodeType currentNodeType = currentNode.getPrimaryNodeType();
NodeDefinition[] childDefs = currentNodeType.getChildNodeDefinitions();
List<String> templates = templateService.getDocumentTemplates();
try {
for (int i = 0; i < templates.size(); i++) {
String nodeTypeName = templates.get(i).toString();
NodeType nodeType = ntManager.getNodeType(nodeTypeName);
NodeType[] superTypes = nodeType.getSupertypes();
boolean isCanCreateDocument = false;
for (NodeDefinition childDef : childDefs) {
NodeType[] requiredChilds = childDef.getRequiredPrimaryTypes();
for (NodeType requiredChild : requiredChilds) {
if (nodeTypeName.equals(requiredChild.getName())) {
isCanCreateDocument = true;
break;
}
}
if (nodeTypeName.equals(childDef.getName()) || isCanCreateDocument) {
if (!nodeTypes.contains(nodeTypeName)) nodeTypes.add(nodeTypeName);
isCanCreateDocument = true;
}
}
if (!isCanCreateDocument) {
for (NodeType superType : superTypes) {
for (NodeDefinition childDef : childDefs) {
for (NodeType requiredType : childDef.getRequiredPrimaryTypes()) {
if (superType.getName().equals(requiredType.getName())) {
if (!nodeTypes.contains(nodeTypeName)) nodeTypes.add(nodeTypeName);
isCanCreateDocument = true;
break;
}
}
if (isCanCreateDocument) break;
}
if (isCanCreateDocument) break;
}
}
}
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error("Unexpected error", e);
}
}
return nodeTypes;
}
/**
* Get node nt:file if node support multi-language
*
* @param currentNode Current Node
* @return Node which has type nt:file
* @throws Exception
*/
public static Node getFileLangNode(Node currentNode) throws Exception {
if (currentNode.isNodeType(NT_UNSTRUCTURED)) {
if (currentNode.getNodes().getSize() > 0) {
NodeIterator nodeIter = currentNode.getNodes();
while (nodeIter.hasNext()) {
Node ntFile = nodeIter.nextNode();
if (ntFile.getPrimaryNodeType().getName().equals(NT_FILE)) {
return ntFile;
}
}
return currentNode;
}
}
return currentNode;
}
@Override
public JcrNode getRootNode() throws RemoteException {
try {
// take root node
Node root = session().getRootNode();
// convert into value object
JcrNode node = new JcrNode("root", root.getPath(), root.getPrimaryNodeType().getName());
node.setProperties(getProperties(root));
node.setAcessControlList(getAccessList(session().getAccessControlManager(), root));
return node;
} catch (RepositoryException e) {
throw new RemoteException(e.getMessage());
}
}
@Before
public void setUp() throws Exception {
initMocks(this);
testObj = new FedoraVersions();
mockSession = mockSession(testObj);
setField(testObj, "nodeService", mockNodes);
setField(testObj, "uriInfo", getUriInfoImpl());
setField(testObj, "session", mockSession);
setField(testObj, "versionService", mockVersions);
setField(testObj, "sessionFactory", mockSessionFactory);
when(mockSessionFactory.getInternalSession()).thenReturn(mockSession);
when(mockNode.getPath()).thenReturn("/test/path");
when(mockResource.getNode()).thenReturn(mockNode);
when(mockNodeType.getName()).thenReturn("nt:folder");
when(mockNode.getPrimaryNodeType()).thenReturn(mockNodeType);
}
public String getContentType() {
String ct = "application/octet-stream";
try {
if (node.getPrimaryNodeType().getName().equals(JcrConstants.NT_FILE)) {
Node contentNode = node.getNode(JcrConstants.JCR_CONTENT);
ct = contentNode.getProperty(JcrConstants.JCR_MIMETYPE).getString();
} else {
if (node.hasProperty(MessageConstants.PROP_SAKAI_CONTENT_TYPE)) {
ct = node.getProperty(MessageConstants.PROP_SAKAI_CONTENT_TYPE).getString();
}
}
} catch (RepositoryException re) {
LOGGER.error(re.getMessage(), re);
}
return ct;
}
private boolean isPrimaryType(final Resource resource, final String primaryType) {
Node node = resource.adaptTo(Node.class);
if (node != null) {
// JCR-based resource resolver
try {
return StringUtils.equals(node.getPrimaryNodeType().getName(), primaryType);
} catch (RepositoryException ex) {
// ignore
return false;
}
} else {
// sling resource resolver mock
ValueMap props = resource.getValueMap();
return StringUtils.equals(props.get(JcrConstants.JCR_PRIMARYTYPE, String.class), primaryType);
}
}
private static void updateMainActivity(
ActivityManager activityManager, Node contentNode, ExoSocialActivity activity) {
Map<String, String> activityParams = activity.getTemplateParams();
String state;
String nodeTitle;
String nodeType = null;
String nodeIconName = null;
String documentTypeLabel;
String currentVersion = null;
TemplateService templateService = WCMCoreUtils.getService(TemplateService.class);
try {
nodeType = contentNode.getPrimaryNodeType().getName();
documentTypeLabel = templateService.getTemplateLabel(nodeType);
} catch (Exception e) {
documentTypeLabel = "";
}
try {
nodeTitle = org.exoplatform.ecm.webui.utils.Utils.getTitle(contentNode);
} catch (Exception e1) {
nodeTitle = "";
}
try {
state =
contentNode.hasProperty(CURRENT_STATE_PROP)
? contentNode.getProperty(CURRENT_STATE_PROP).getValue().getString()
: "";
} catch (Exception e) {
state = "";
}
try {
currentVersion = contentNode.getBaseVersion().getName();
// TODO Must improve this hardcode later, need specification
if (currentVersion.contains("jcr:rootVersion")) currentVersion = "0";
} catch (Exception e) {
currentVersion = "";
}
activityParams.put(ContentUIActivity.STATE, state);
activityParams.put(ContentUIActivity.DOCUMENT_TYPE_LABEL, documentTypeLabel);
activityParams.put(ContentUIActivity.DOCUMENT_TITLE, nodeTitle);
activityParams.put(ContentUIActivity.DOCUMENT_VERSION, currentVersion);
String summary = getSummary(contentNode);
summary = getFirstSummaryLines(summary, MAX_SUMMARY_LINES_COUNT);
activityParams.put(ContentUIActivity.DOCUMENT_SUMMARY, summary);
activity.setTemplateParams(activityParams);
activityManager.updateActivity(activity);
}
/**
* Get allowed folder types in current path.
*
* @param currentNode
* @param currentDrive
* @return List<String> of node types
* @throws Exception
*/
public static List<String> getAllowedFolderTypesInCurrentPath(
Node currentNode, DriveData currentDrive) throws Exception {
List<String> allowedTypes = new ArrayList<String>();
NodeTypeImpl currentNodeType = (NodeTypeImpl) currentNode.getPrimaryNodeType();
String[] arrFoldertypes = currentDrive.getAllowCreateFolders().split(",");
NodeTypeManager ntManager = currentNode.getSession().getWorkspace().getNodeTypeManager();
for (String strFolderType : arrFoldertypes) {
if (strFolderType.isEmpty()) continue;
NodeType folderType = ntManager.getNodeType(strFolderType);
if ((currentNodeType)
.isChildNodePrimaryTypeAllowed(
Constants.JCR_ANY_NAME, ((NodeTypeImpl) folderType).getQName())) {
allowedTypes.add(strFolderType);
}
}
return allowedTypes;
}
protected Node getNodeToCheckState(Node node) throws Exception {
Node displayNode = node;
if (displayNode.isNodeType("nt:resource")) {
displayNode = node.getParent();
}
// return exo:webContent when exo:htmlFile found
if (displayNode.isNodeType("exo:htmlFile")) {
Node parent = displayNode.getParent();
if (parent.isNodeType("exo:webContent")) return parent;
return displayNode;
}
//
String[] contentTypes = queryCriteria.getContentTypes();
if (contentTypes != null && contentTypes.length > 0) {
String primaryNodeType = displayNode.getPrimaryNodeType().getName();
if (!ArrayUtils.contains(contentTypes, primaryNodeType)) return null;
}
return displayNode;
}
public InputStream getInputStream() throws IOException {
InputStream is = null;
try {
if (node.getPrimaryNodeType().getName().equals(JcrConstants.NT_FILE)) {
Node contentNode = node.getNode(JcrConstants.JCR_CONTENT);
is = contentNode.getProperty(JcrConstants.JCR_DATA).getBinary().getStream();
} else {
is =
node.getProperty(MessageConstants.PROP_SAKAI_ATTACHMENT_CONTENT)
.getBinary()
.getStream();
}
} catch (RepositoryException e) {
LOGGER.error(e.getMessage(), e);
// in Java 1.6 this would be "throw new IOException(e)" the following is a 1.5 hack
// to get the same result
throw (IOException) new IOException(e.getMessage()).initCause(e);
}
return is;
}
private boolean isChildNodePrimaryTypeAllowed(Node parent, String childNodeTypeName)
throws Exception {
NodeType childNodeType =
parent.getSession().getWorkspace().getNodeTypeManager().getNodeType(childNodeTypeName);
// In some cases, the child node is mixins type of a nt:file example
if (childNodeType.isMixin()) return true;
List<NodeType> allNodeTypes = new ArrayList<NodeType>();
allNodeTypes.add(parent.getPrimaryNodeType());
for (NodeType mixin : parent.getMixinNodeTypes()) {
allNodeTypes.add(mixin);
}
for (NodeType nodetype : allNodeTypes) {
if (((NodeTypeImpl) nodetype)
.isChildNodePrimaryTypeAllowed(
Constants.JCR_ANY_NAME, ((NodeTypeImpl) childNodeType).getQName())) {
return true;
}
}
return false;
}
private int type(Node node, String propertyName) throws RepositoryException {
PropertyDefinition[] defs = node.getPrimaryNodeType().getPropertyDefinitions();
for (PropertyDefinition def : defs) {
if (def.getName().equals(propertyName)) {
return def.getRequiredType();
}
}
NodeType[] mixins = node.getMixinNodeTypes();
for (NodeType type : mixins) {
defs = type.getPropertyDefinitions();
for (PropertyDefinition def : defs) {
if (def.getName().equals(propertyName)) {
return def.getRequiredType();
}
}
}
return -1;
}
