/**
* refine node for validation
*
* @param currentNode
* @throws Exception
*/
private static void refineNode(Node currentNode) throws Exception {
if (currentNode instanceof NodeImpl && !((NodeImpl) currentNode).isValid()) {
ExoContainer container = ExoContainerContext.getCurrentContainer();
LinkManager linkManager =
(LinkManager) container.getComponentInstanceOfType(LinkManager.class);
if (linkManager.isLink(currentNode)) {
try {
currentNode = linkManager.getTarget(currentNode, false);
} catch (RepositoryException ex) {
currentNode = linkManager.getTarget(currentNode, true);
}
}
}
}
/**
* Test method TaxonomyService.init() Expect: Create system taxonomy tree in dms-system
*
* @see {@link # testInit()}
*/
public void testInit() throws Exception {
Node systemTreeDef = (Node) dmsSesssion.getItem(definitionPath + "/System");
Node systemTreeStorage = (Node) dmsSesssion.getItem(storagePath + "/System");
assertNotNull(systemTreeDef);
assertNotNull(systemTreeStorage);
assertEquals(systemTreeStorage, linkManage.getTarget(systemTreeDef, true));
}
/**
* Test method TaxonomyService.addCategories() Input: add 2 categories in article node Output:
* create 2 exo:taxonomyLink in each category
*
* @throws RepositoryException
* @throws TaxonomyNodeAlreadyExistsException
* @throws TaxonomyAlreadyExistsException
*/
public void testAddCategories()
throws RepositoryException, TaxonomyNodeAlreadyExistsException,
TaxonomyAlreadyExistsException {
session.getRootNode().addNode("MyDocuments");
Node article = session.getRootNode().addNode("Article");
session.save();
taxonomyService.addTaxonomyNode(COLLABORATION_WS, "/MyDocuments", "Serie", "root");
taxonomyService.addTaxonomyNode(COLLABORATION_WS, "/MyDocuments/Serie", "A", "root");
taxonomyService.addTaxonomyNode(COLLABORATION_WS, "/MyDocuments/Serie", "B", "root");
Node rootTree = (Node) session.getItem("/MyDocuments/Serie");
taxonomyService.addTaxonomyTree(rootTree);
taxonomyService.addCategories(article, "Serie", new String[] {"A", "B"}, true);
Node link1 = (Node) session.getItem("/MyDocuments/Serie/A/Article");
Node link2 = (Node) session.getItem("/MyDocuments/Serie/B/Article");
assertTrue(link1.isNodeType("exo:taxonomyLink"));
assertEquals(article, linkManage.getTarget(link1));
assertTrue(link2.isNodeType("exo:taxonomyLink"));
assertEquals(article, linkManage.getTarget(link2));
}
/**
* Gets the node by category.
*
* @param parameters the parameters
* @return the node by category
* @throws Exception the exception
*/
private Node getNodeByCategory(String parameters) throws Exception {
try {
if (taxonomyService == null) taxonomyService = WCMCoreUtils.getService(TaxonomyService.class);
Node taxonomyTree = taxonomyService.getTaxonomyTree(parameters.split("/")[0]);
Node symlink = taxonomyTree.getNode(parameters.substring(parameters.indexOf("/") + 1));
return linkManager.getTarget(symlink);
} catch (Exception e) {
return null;
}
}
/**
* Test method TaxonomyService.getTaxonomyTree(String repository, String taxonomyName) Input:
* Create taxonomy tree Music Expect: Node Music
*
* @throws RepositoryException
* @throws TaxonomyNodeAlreadyExistsException
* @throws TaxonomyAlreadyExistsException
*/
public void testGetTaxonomyTree2()
throws RepositoryException, TaxonomyNodeAlreadyExistsException,
TaxonomyAlreadyExistsException {
session.getRootNode().addNode("MyDocuments");
session.save();
taxonomyService.addTaxonomyNode(COLLABORATION_WS, "/MyDocuments", "Music", "root");
Node musicTree = (Node) session.getItem("/MyDocuments/Music");
taxonomyService.addTaxonomyTree(musicTree);
assertTrue(dmsSesssion.itemExists(definitionPath + "/Music"));
Node musicTreeDefinition = (Node) dmsSesssion.getItem(definitionPath + "/Music");
assertEquals(musicTree, linkManage.getTarget(musicTreeDefinition, true));
}
public static Node getNodeSymLink(Node node) throws Exception {
LinkManager linkManager = Util.getUIPortal().getApplicationComponent(LinkManager.class);
Node realNode = null;
if (linkManager.isLink(node)) {
if (linkManager.isTargetReachable(node)) {
realNode = linkManager.getTarget(node);
}
} else {
realNode = node;
}
return realNode;
}
private Node getTargetNode(Node showingNode) throws Exception {
Node targetNode = null;
if (linkManager.isLink(showingNode)) {
try {
targetNode = linkManager.getTarget(showingNode);
} catch (ItemNotFoundException e) {
targetNode = showingNode;
}
} else {
targetNode = showingNode;
}
return targetNode;
}
private CategoryNode getCategoryNode(Node node, String parentPath) {
CategoryNode categoryNode = null;
try {
if (node.isNodeType("exo:taxonomy")) {
categoryNode = new CategoryNode(node.getName(), "", parentPath, getType(node));
} else if (linkManager_.isLink(node)) {
// In case document type, don't need parentId
node = linkManager_.getTarget(node);
categoryNode = new CategoryNode(node.getName(), "", "", getType(node));
}
} catch (ItemNotFoundException e) {
LOG.error(e);
} catch (RepositoryException e) {
LOG.error(e);
} catch (Exception e) {
LOG.error(e);
}
return categoryNode;
}
private List<DocumentContent> getArticleNode(Node node, List<String> allDocumentType)
throws Exception {
List<DocumentContent> docs = new ArrayList<DocumentContent>();
NodeIterator nodes = node.getNodes();
Node docNode;
List<Node> taxonomyTrees =
taxonomyService_.getAllTaxonomyTrees(
((ManageableRepository) node.getSession().getRepository())
.getConfiguration()
.getName());
while (nodes.hasNext()) {
docNode = nodes.nextNode();
if (linkManager_.isLink(docNode)) {
docNode = linkManager_.getTarget(docNode);
if (allDocumentType.contains(docNode.getPrimaryNodeType().getName())) {
docs.add(getArticleContent(docNode, taxonomyTrees));
}
}
}
return docs;
}
@GET
@Path("/articles/{repoName}/{docPath:.*}/")
public Response getArticles(
@PathParam("repoName") String repoName, @PathParam("docPath") String docPath) {
DocumentContent docNode = null;
ListResultNode listResultNode = new ListResultNode();
if (docPath != null) {
String taxonomyTree = docPath.split("/")[0];
String path = docPath.substring(taxonomyTree.length());
if (path.startsWith("/")) {
path = path.substring(1);
}
try {
if (documentTypes.isEmpty())
documentTypes = templateService_.getAllDocumentNodeTypes(repoName);
Node taxonomyNode = taxonomyService_.getTaxonomyTree(repoName, taxonomyTree);
if (taxonomyNode == null)
throw new PathNotFoundException("Can't find category " + taxonomyTree);
if (!path.equals("")) {
taxonomyNode = taxonomyNode.getNode(path);
}
if (linkManager_.isLink(taxonomyNode)) {
List<Node> taxonomyTrees = taxonomyService_.getAllTaxonomyTrees(repoName);
docNode = getArticleContent(linkManager_.getTarget(taxonomyNode), taxonomyTrees);
return Response.ok(docNode, new MediaType("application", "json")).build();
} else if (taxonomyNode.isNodeType("exo:taxonomy")) {
listResultNode.setLstNode(getArticleNode(taxonomyNode, documentTypes));
Collections.sort(listResultNode.getLstNode(), new NameComparator());
return Response.ok(listResultNode, new MediaType("application", "json")).build();
}
} catch (PathNotFoundException exc) {
LOG.error("Path Not found " + exc.getMessage(), exc);
return Response.status(HTTPStatus.NOT_FOUND).entity(exc.getMessage()).build();
} catch (Exception e) {
LOG.error(e);
return Response.serverError().build();
}
}
return Response.ok().build();
}
/**
* GetRealNode
*
* @param strRepository
* @param strWorkspace
* @param strIdentifier
* @param cacheVisibility the visibility of cache
* @return the required node/ the target of a symlink node / null if node was in trash.
* @throws RepositoryException
*/
public static Node getRealNode(
String strRepository,
String strWorkspace,
String strIdentifier,
boolean isWCMBase,
String cacheVisibility)
throws RepositoryException {
LinkManager linkManager = WCMCoreUtils.getService(LinkManager.class);
Node selectedNode;
if (isWCMBase) {
selectedNode =
getViewableNodeByComposer(
strRepository,
strWorkspace,
strIdentifier,
WCMComposer.BASE_VERSION,
cacheVisibility);
} else {
selectedNode =
getViewableNodeByComposer(
strRepository, strWorkspace, strIdentifier, null, cacheVisibility);
}
if (selectedNode != null) {
if (!org.exoplatform.ecm.webui.utils.Utils.isInTrash(selectedNode)) {
if (linkManager.isLink(selectedNode)) {
if (linkManager.isTargetReachable(selectedNode)) {
selectedNode = linkManager.getTarget(selectedNode);
if (!org.exoplatform.ecm.webui.utils.Utils.isInTrash(selectedNode)) {
return selectedNode;
}
}
} else {
return selectedNode;
}
}
}
return null;
}