/**
  * Valorizza un nodo in base alle informazioni specificate..
  *
  * @param nodeToValue Il nodo da valorizzare.
  * @param parent Il nodo parente.
  * @param realNode Il nodo dal quela estrarre le info.
  */
 protected void fillTreeNode(TreeNode nodeToValue, TreeNode parent, ITreeNode realNode) {
   nodeToValue.setCode(realNode.getCode());
   if (null == parent) {
     nodeToValue.setParent(nodeToValue);
   } else {
     nodeToValue.setParent(parent);
   }
   Set<Object> codes = realNode.getTitles().keySet();
   Iterator<Object> iterKey = codes.iterator();
   while (iterKey.hasNext()) {
     String key = (String) iterKey.next();
     String title = realNode.getTitles().getProperty(key);
     nodeToValue.getTitles().put(key, title);
   }
 }
 private void addTreeWrapper(TreeNode currentNode, TreeNode parent, ITreeNode currentTreeNode) {
   ITreeNode[] children = currentTreeNode.getChildren();
   for (int i = 0; i < children.length; i++) {
     ITreeNode newCurrentTreeNode = children[i];
     TreeNode newNode = new TreeNode();
     this.fillTreeNode(newNode, currentNode, newCurrentTreeNode);
     currentNode.addChild(newNode);
     this.addTreeWrapper(newNode, currentNode, newCurrentTreeNode);
   }
 }
Exemplo n.º 3
0
 protected Query createQuery(
     SearchEngineFilter[] filters,
     Collection<ITreeNode> categories,
     Collection<String> allowedGroups) {
   BooleanQuery mainQuery = new BooleanQuery();
   if (filters != null && filters.length > 0) {
     for (int i = 0; i < filters.length; i++) {
       SearchEngineFilter filter = filters[i];
       Query fieldQuery = this.createQuery(filter);
       mainQuery.add(fieldQuery, BooleanClause.Occur.MUST);
     }
   }
   if (allowedGroups == null) {
     allowedGroups = new HashSet<String>();
   }
   if (!allowedGroups.contains(Group.ADMINS_GROUP_NAME)) {
     if (!allowedGroups.contains(Group.FREE_GROUP_NAME)) {
       allowedGroups.add(Group.FREE_GROUP_NAME);
     }
     BooleanQuery groupsQuery = new BooleanQuery();
     Iterator<String> iterGroups = allowedGroups.iterator();
     while (iterGroups.hasNext()) {
       String group = iterGroups.next();
       TermQuery groupQuery = new TermQuery(new Term(IIndexerDAO.CONTENT_GROUP_FIELD_NAME, group));
       groupsQuery.add(groupQuery, BooleanClause.Occur.SHOULD);
     }
     mainQuery.add(groupsQuery, BooleanClause.Occur.MUST);
   }
   if (null != categories && !categories.isEmpty()) {
     BooleanQuery categoriesQuery = new BooleanQuery();
     Iterator<ITreeNode> cateIter = categories.iterator();
     while (cateIter.hasNext()) {
       ITreeNode category = cateIter.next();
       String path = category.getPath(IIndexerDAO.CONTENT_CATEGORY_SEPARATOR, false);
       TermQuery categoryQuery =
           new TermQuery(new Term(IIndexerDAO.CONTENT_CATEGORY_FIELD_NAME, path));
       categoriesQuery.add(categoryQuery, BooleanClause.Occur.MUST);
     }
     mainQuery.add(categoriesQuery, BooleanClause.Occur.MUST);
   }
   return mainQuery;
 }
 @Override
 public Set<String> checkTargetNodesOnClosing(
     String nodeToCloseCode, Set<String> lastOpenedNodes, Collection<String> groupCodes)
     throws ApsSystemException {
   ITreeNode nodeToClose = this.getTreeNode(nodeToCloseCode);
   if (null == nodeToCloseCode || null == nodeToClose) {
     return this.checkTargetNodes(null, lastOpenedNodes, groupCodes);
   }
   Set<String> checkedTargetNodes = new HashSet<String>();
   try {
     if (nodeToClose.isRoot()) {
       return checkedTargetNodes;
     }
     if (null != lastOpenedNodes) {
       Iterator<String> iter = lastOpenedNodes.iterator();
       while (iter.hasNext()) {
         String code = (String) iter.next();
         if (null != code
             && this.checkNode(code, groupCodes)
             && !code.equals(nodeToCloseCode)
             && !this.getTreeNode(code).isChildOf(nodeToCloseCode)) {
           checkedTargetNodes.add(code);
         }
       }
     }
     if (null != nodeToClose
         && null != nodeToClose.getParent()
         && this.checkNode(nodeToClose.getParent().getCode(), groupCodes)) {
       checkedTargetNodes.add(nodeToClose.getParent().getCode());
     }
   } catch (Throwable t) {
     ApsSystemUtils.logThrowable(t, this, "checkTargetNodesOnClosing");
     throw new ApsSystemException("Error check target nodes on closing tree", t);
   }
   return checkedTargetNodes;
 }
 protected void buildCheckNodes(
     ITreeNode treeNode, Set<String> checkNodes, Collection<String> groupCodes) {
   checkNodes.add(treeNode.getCode());
   ITreeNode parent = treeNode.getParent();
   if (parent != null
       && parent.getParent() != null
       && !parent.getCode().equals(treeNode.getCode())) {
     this.buildCheckNodes(parent, checkNodes, groupCodes);
   }
 }
 private void builShowableTree(
     TreeNodeWrapper currentNode,
     TreeNodeWrapper parent,
     ITreeNode currentTreeNode,
     Set<String> checkNodes) {
   if (checkNodes.contains(currentNode.getCode())) {
     currentNode.setOpen(true);
     ITreeNode[] children = currentTreeNode.getChildren();
     for (int i = 0; i < children.length; i++) {
       ITreeNode newCurrentTreeNode = children[i];
       TreeNodeWrapper newNode = new TreeNodeWrapper(newCurrentTreeNode);
       newNode.setParent(currentNode);
       currentNode.addChild(newNode);
       this.builShowableTree(newNode, currentNode, newCurrentTreeNode, checkNodes);
     }
   }
 }