Exemplo n.º 1
0
  /**
   * Método que carrega a arvore para uma lista de permissoes
   *
   * @param permissoes - as permissoes a serem exibidas
   * @param permissoesParaSelecionar - as permissoes que ficarao selecionadas
   * @return
   */
  public TreeNode getTreeNode(
      List<Permissao> permissoes, List<Permissao> permissoesParaSelecionar) {
    TreeNode root = new DefaultTreeNode();
    root.setExpanded(true);

    Map<Permissao, TreeNode> nodeMap = new LinkedHashMap<Permissao, TreeNode>();

    // criar nó para cada permissao
    for (Permissao permissao : permissoes) {
      adicionarPermissaoAoMap(root, permissao, nodeMap, permissoes, permissoesParaSelecionar, true);
    }
    for (Map.Entry<Permissao, TreeNode> entry : nodeMap.entrySet()) {

      Permissao permissao = entry.getKey();
      TreeNode node = entry.getValue();
      if (permissao.getPermissaoPai() != null) {
        TreeNode parent = nodeMap.get(permissao.getPermissaoPai());
        // selecionar apenas ate o segundo nivel
        if (parent != null && parent.isSelected()) {
          node.setSelected(true);
        }
        node.setExpanded(false);
        if (parent != null) {
          parent.getChildren().add(node);
        } else {
          root.getChildren().add(node);
        }
      }
    }
    return root;
  }
Exemplo n.º 2
0
 /**
  * @param parent
  * @param indexes
  * @return
  */
 protected TreeNode findNodeFromPath(TreeNode parent, List<Integer> indexes) {
   if (indexes.size() > 1) {
     return findNodeFromPath(
         parent.getChildren().get(indexes.get(0)), indexes.subList(1, indexes.size()));
   } else {
     return parent.getChildren().get(indexes.get(0));
   }
 }
Exemplo n.º 3
0
  /** @return the filterNode */
  public TreeNode getFilterNode() {
    if (model != null && model.isInitialized()) {
      Hierarchy hierarchy = getHierarchy();

      if (filterNode == null && hierarchy != null) {
        this.filterNode = new DefaultTreeNode();

        filterNode.setExpanded(true);

        List<Member> members;
        boolean isMeasure;

        try {
          members = hierarchy.getRootMembers();
          isMeasure = hierarchy.getDimension().getDimensionType() == Type.MEASURE;
        } catch (OlapException e) {
          throw new FacesException(e);
        }

        for (Member member : members) {
          if (isMeasure && !member.isVisible()) {
            continue;
          }

          MemberNode node = new MemberNode(member);

          node.setNodeFilter(this);
          node.setExpanded(true);
          node.setSelectable(true);
          node.setSelected(isSelected(member));

          filterNode.getChildren().add(node);
        }

        List<TreeNode> initialSelection =
            ((DefaultTreeNode) filterNode)
                .collectNodes(
                    new NodeCollector() {

                      @Override
                      public boolean collectNode(TreeNode node) {
                        return node.isSelected();
                      }

                      @Override
                      public boolean searchNode(TreeNode node) {
                        return node.isExpanded();
                      }
                    });

        this.selection = initialSelection.toArray(new TreeNode[initialSelection.size()]);
      }
    } else {
      this.filterNode = null;
    }

    return filterNode;
  }
Exemplo n.º 4
0
 /** Removes all child nodes of the supplied root node. */
 private void removeAllChildsOfRootNode(final TreeNode rootNode) {
   if ((rootNode != null) && (rootNode.getChildCount() > 0)) {
     final TreeNode[] array =
         rootNode.getChildren().toArray(new TreeNode[rootNode.getChildCount()]);
     for (TreeNode child : array) {
       child.setParent(null);
       child = null;
     }
   }
 }
Exemplo n.º 5
0
 @SuppressWarnings("unchecked")
 private static Set<String> toSelection(final TreeNode treeNodes) {
   Set<String> selection = new HashSet<String>();
   for (TreeNode treeNode : treeNodes.getChildren()) {
     if (treeNode.isSelected()) {
       selection.add(((Pair<String, String>) treeNode.getData()).getValue());
     }
   }
   return selection;
 }
  public void tableToTree() {
    Map<String, String> params =
        FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
    int colIndex = Integer.parseInt(params.get("colIndex"));

    // remove from table
    ColumnModel model = this.columns.remove(colIndex);

    // add to nodes
    TreeNode property = new DefaultTreeNode("column", model, availableColumns.getChildren().get(0));
  }
Exemplo n.º 7
0
  private void selectClassificationInTree(TreeNode raiz, List<Classification> selectedlist) {
    List<TreeNode> children = raiz.getChildren();

    for (Classification c : selectedlist) {
      if (raiz.getData() != null && raiz.getData().equals(c)) {
        raiz.setSelected(true);
        getSelectednodesList().add(raiz);
      }
    }

    for (TreeNode hijo : children) {
      selectClassificationInTree(hijo, selectedlist);
    }
  }
Exemplo n.º 8
0
  private void updateNodeForSelected(final TreeNode treeNode, final TreeNode selectedTreeNode) {
    if ((selectedTreeNode != null) && (treeNode != null)) {
      if (treeNode == selectedTreeNode) {
        selectedTreeNode.setSelected(true);
      } else {
        treeNode.setSelected(false);
      }

      if (treeNode.getChildCount() != 0) {
        for (final TreeNode child : treeNode.getChildren()) {
          updateNodeForSelected(child, selectedTreeNode);
        }
      }
    }
  }
  public void treeToTable() {
    Map<String, String> params =
        FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
    String property = params.get("property");
    String droppedColumnId = params.get("droppedColumnId");
    String dropPos = params.get("dropPos");

    String[] droppedColumnTokens = droppedColumnId.split(":");
    int draggedColumnIndex = Integer.parseInt(droppedColumnTokens[droppedColumnTokens.length - 1]);
    int dropColumnIndex = draggedColumnIndex + Integer.parseInt(dropPos);

    // add to columns
    this.columns.add(dropColumnIndex, new ColumnModel(property.toUpperCase(), property));

    // remove from nodes
    TreeNode root = availableColumns.getChildren().get(0);
    for (TreeNode node : root.getChildren()) {
      ColumnModel model = (ColumnModel) node.getData();
      if (model.getProperty().equals(property)) {
        root.getChildren().remove(node);
        break;
      }
    }
  }
  private boolean possuiFilhoSelecionado(TreeNode node) {
    boolean possui = false;

    if (node.getChildCount() > 0) {
      for (TreeNode filho : node.getChildren()) {
        if (filho.isSelected()) {
          possui = true;
          break;
        } else {
          possui = possuiFilhoSelecionado(filho);
          if (possui) {
            break;
          }
        }
      }
    }
    return possui;
  }
  /**
   * RECURSIVO! Converte o TreeNode do PrimeFaces para a ArvoreSimples Na primeira chamada, o
   * segundo argumento deve ser nulo, simbolizando a raiz. O retorno da primeira chamada eh a raiz.
   */
  public ArvoreSimples converterArvorePrimeParaArvoreSimples(
      TreeNode treeNode, ArvoreSimples arvore, boolean apenasSelecionados) {
    ChaveValor<String, String> chaveValor = (ChaveValor<String, String>) treeNode.getData();
    ArvoreSimples arvoreSimples = new ArvoreSimples(chaveValor.getChave(), chaveValor.getValor());

    if (arvore != null) { // -- da primeira vez nao tem pai, nas proximas eh a recursao dos filhos
      arvore.getFilhos().add(arvoreSimples);
    }

    if (treeNode.getChildCount() > 0) {
      for (TreeNode nivel : treeNode.getChildren()) {
        if (apenasSelecionados) {
          boolean possui = possuiFilhoSelecionado(nivel);
          if (!possui && !nivel.isSelected()) {
            continue;
          }
        }

        converterArvorePrimeParaArvoreSimples(nivel, arvoreSimples, apenasSelecionados);
      }
    }
    return arvoreSimples;
  }
  /**
   * enlista los estados, muestra por defecto las actividades el primer estado que conigue las
   * actividades y del primer grupo de consigue.
   */
  @PostConstruct
  public void init() {

    if (verificarLogueo()) {
      Redireccionar();
    } else {
      estact = new DefaultTreeNode("root", null);
      idusu = new Usuario();
      FacesContext fc = FacesContext.getCurrentInstance();
      ExternalContext ec = fc.getExternalContext();
      HttpSession sesion = (HttpSession) ec.getSession(true);
      sesion_actual = (Sesion) (sesion.getAttribute("Sesion"));
      idusu = (Usuario) (sesion.getAttribute("Usuario"));
      String icono;
      // bande=consultarBandejas(idusu);
      estados = buscarEstados();
      int i = 0;

      while (estados.size() > i) {
        if ("abierta".equals(estados.get(i))) {
          icono = "s";
        } else if ("pendiente".equals(estados.get(i))) {
          icono = "i";
        } else if ("cerrada".equals(estados.get(i))) {
          icono = "t";
        } else {
          icono = "j";
        }
        TreeNode inbox = new DefaultTreeNode(icono, estados.get(i), estact);
        i++;
      }

      grupos = this.gruposUsuario(idusu);
      estadoSeleccionado = estact.getChildren().get(0);
      indice = 0;
      estact.getChildren().get(0).setSelected(true);
      int j = 0;
      activi = new Actividad();
      activi.setEstado(estados.get(j));
      actividad = consultarActividades(idusu, activi);
      actividades = new ArrayList<Actividad>();
      grupoSeleccionado = grupos.get(0);
      GrupoPanel = grupoSeleccionado.getNombre();
      if (actividad.getActividads().isEmpty()) {
        actividades = null;
      }
      while (actividad.getActividads().size() > j) {
        act = actividad.getActividads().get(j);
        if (act.getIdInstancia()
                .getIdPeriodoGrupoProceso()
                .getIdGrupo()
                .getId()
                .compareTo(grupoSeleccionado.getId())
            != 0) {
        } else {
          actividades.add(act);
        }

        j++;
      }
    }
  }