org.roda.wui.common.client.tools.FacetUtils.java Source code

Introduction

Here is the source code for org.roda.wui.common.client.tools.FacetUtils.java

Source

/**
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE file at the root of the source
 * tree and available online at
 *
 * https://github.com/keeps/roda
 */
package org.roda.wui.common.client.tools;

import java.util.List;
import java.util.Map;

import org.roda.core.data.v2.index.IndexResult;
import org.roda.core.data.v2.index.IsIndexed;
import org.roda.core.data.v2.index.facet.FacetFieldResult;
import org.roda.core.data.v2.index.facet.FacetParameter;
import org.roda.core.data.v2.index.facet.FacetValue;
import org.roda.core.data.v2.index.facet.Facets;
import org.roda.wui.client.common.lists.utils.AsyncTableCell;
import org.roda.wui.common.client.ClientLogger;

import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.user.client.ui.CheckBox;
import com.google.gwt.user.client.ui.FlowPanel;

public class FacetUtils {

    private FacetUtils() {

    }

    private static ClientLogger LOGGER = new ClientLogger(FacetUtils.class.getName());

    public static <T extends IsIndexed> void bindFacets(final AsyncTableCell<T, ?> list,
            final Map<String, FlowPanel> facetPanels) {
        bindFacets(list, facetPanels, false);
    }

    public static <T extends IsIndexed> void bindFacets(final AsyncTableCell<T, ?> list,
            final Map<String, FlowPanel> facetPanels, final boolean hideDisabled) {
        list.addValueChangeHandler(new ValueChangeHandler<IndexResult<T>>() {

            @Override
            public void onValueChange(ValueChangeEvent<IndexResult<T>> event) {
                FacetUtils.updateFacetPanels(list, facetPanels, event.getValue().getFacetResults(), hideDisabled);
            }
        });
    }

    private static <T extends IsIndexed> void updateFacetPanels(final AsyncTableCell<T, ?> list,
            final Map<String, FlowPanel> facetPanels, final List<FacetFieldResult> facetResults,
            final boolean hideDisabled) {

        for (FacetFieldResult facetResult : facetResults) {
            final String facetField = facetResult.getField();
            FlowPanel facetPanel = facetPanels.get(facetResult.getField());
            if (facetPanel != null) {
                facetPanel.clear();
                if (facetResult.getTotalCount() == 0) {
                    facetPanel.getParent().addStyleName("facet-empty");
                } else {
                    facetPanel.getParent().removeStyleName("facet-empty");
                }

                for (FacetValue facetValue : facetResult.getValues()) {
                    final String value = facetValue.getValue();
                    final String label = facetValue.getLabel();
                    long count = facetValue.getCount();
                    boolean selected = facetResult.getSelectedValues().contains(value);
                    StringBuilder checkboxLabel = new StringBuilder();
                    checkboxLabel.append(label);
                    if (count > 0 || facetResult.getSelectedValues().isEmpty() || selected) {
                        checkboxLabel.append(" (").append(count).append(")");
                    }

                    CheckBox facetValuePanel = new CheckBox(checkboxLabel.toString());
                    facetValuePanel.setTitle(checkboxLabel.toString());
                    facetValuePanel.addStyleName("sidebar-facet-label");
                    facetValuePanel.addStyleName("fade-out");

                    boolean enabled = count > 0 || !facetResult.getSelectedValues().isEmpty();
                    facetValuePanel.setEnabled(enabled);
                    if (hideDisabled) {
                        facetValuePanel.setVisible(enabled);
                    }

                    facetPanel.add(facetValuePanel);
                    facetValuePanel.setValue(selected);

                    facetValuePanel.addValueChangeHandler(new ValueChangeHandler<Boolean>() {

                        @Override
                        public void onValueChange(ValueChangeEvent<Boolean> event) {
                            Facets facets = list.getFacets();
                            FacetParameter selectedFacetParameter = facets.getParameters().get(facetField);

                            if (selectedFacetParameter != null) {
                                if (event.getValue()) {
                                    selectedFacetParameter.getValues().add(value);
                                } else {
                                    selectedFacetParameter.getValues().remove(value);
                                }
                            } else {
                                LOGGER.warn("Haven't found the facet parameter: " + facetField);
                            }
                            list.setFacets(facets);

                        }
                    });
                }

            } else {
                LOGGER.warn("Got a facet but haven't got a panel for it");
            }
        }
    }

    public static boolean hasSelected(Facets facets) {
        boolean hasSelected = false;
        if (facets != null) {
            for (FacetParameter fp : facets.getParameters().values()) {
                if (!fp.getValues().isEmpty()) {
                    hasSelected = true;
                    break;
                }
            }
        }
        return hasSelected;
    }

    public static void clearFacets(Facets facets) {
        for (Map.Entry<String, FacetParameter> entry : facets.getParameters().entrySet()) {
            entry.getValue().getValues().clear();
        }
    }
}