/**
* 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;
}
/**
* @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));
}
}
/** @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;
}
/** 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;
}
}
}
@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));
}
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);
}
}
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++;
}
}
}