source: vlo/branches/to-wicket-1.6/vlo_web_app/src/main/java/eu/clarin/cmdi/vlo/pages/FacetedSearchPage.java @ 4220

package eu.clarin.cmdi.vlo.pages;

import eu.clarin.cmdi.vlo.FacetConstants;
import eu.clarin.cmdi.vlo.Resources;
import eu.clarin.cmdi.vlo.VloPageParameters;
import eu.clarin.cmdi.vlo.config.VloConfig;
import eu.clarin.cmdi.vlo.dao.AutoCompleteDao;
import eu.clarin.cmdi.vlo.importer.FacetConceptMapping.FacetConcept;
import eu.clarin.cmdi.vlo.importer.VLOMarshaller;
import fiftyfive.wicket.basic.TruncatedLabel;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.FacetField;
import org.apache.solr.common.SolrDocument;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.extensions.ajax.markup.html.autocomplete.AutoCompleteTextField;
import org.apache.wicket.extensions.ajax.markup.html.repeater.data.table.AjaxFallbackDefaultDataTable;
import org.apache.wicket.extensions.markup.html.repeater.data.grid.ICellPopulator;
import org.apache.wicket.extensions.markup.html.repeater.data.table.AbstractColumn;
import org.apache.wicket.extensions.markup.html.repeater.data.table.IColumn;
import org.apache.wicket.extensions.markup.html.repeater.data.table.ISortableDataProvider;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.basic.MultiLineLabel;
import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.markup.html.link.ExternalLink;
import org.apache.wicket.markup.repeater.Item;
import org.apache.wicket.markup.repeater.data.GridView;
import org.apache.wicket.markup.repeater.data.IDataProvider;
import org.apache.wicket.model.CompoundPropertyModel;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.ResourceModel;
import org.apache.wicket.request.Url;
import org.apache.wicket.request.cycle.RequestCycle;

public class FacetedSearchPage extends BasePage {

    private static final long serialVersionUID = 1L;

    private final SearchPageQuery query;
    private final static AutoCompleteDao autoCompleteDao = new AutoCompleteDao();
    private final static String facetConceptsFile = VloConfig.getFacetConceptsFile();
    private final static Map<String, FacetConcept> facetNameMap = VLOMarshaller.getFacetConceptMapping(facetConceptsFile).getFacetConceptMap();

    public FacetedSearchPage(PageParameters params) {
        this(VloPageParameters.convert(params));
    }

    /**
     * @param parameters Page parameters
     * @throws SolrServerException
     */
    public FacetedSearchPage(final VloPageParameters parameters) {
        super(parameters);
        query = new SearchPageQuery(parameters);
        addSearchBox();
        addFacetColumns();
        addSearchResults();
        addSearchServiceForm();
    }

    @SuppressWarnings("serial")
    private class SearchBoxForm extends Form<SearchPageQuery> {

        private final AutoCompleteTextField<String> searchBox;

        /*
         * Add multiline list of selected facet values
         */
        private void addFacetOverview() {

            // get a map of the facets currently selected
            Map<String, String> selectedFacets;
            selectedFacets = query.getFilterQueryMap();

            // create an interator for walking over the facets
            Iterator<Map.Entry<String, String>> entries
                    = selectedFacets.entrySet().iterator();

            /*
             * Wicket label to be used to show the list of facets that have been 
             * selected.
             */
            MultiLineLabel facetOverview;

            // walk over the facets
            if (!entries.hasNext()) {
                // not a single facet has been selected
                facetOverview = new MultiLineLabel("facetOverview",
                        "No facets values selected");
            } else {
                // at least one facet has been selected

                String string = "Selected facet values:  ";

                // start building the the multiline label here
                String[] facetFields;
                int i = 0, lineLength = 0,
                        maxLineLength = VloConfig.getFacetOverviewLength();
                Boolean hasPrevious = false;

                /* 
                 * Get the facet fields. We need them in order to display
                 * the values in the overview in the same order as their
                 * respective facets are listed in the boxes. Store multiple
                 * lines in one string.
                 */
                facetFields = VloConfig.getFacetFields();

                while (i < facetFields.length) {

                    // check if facet field is in selected facets map
                    if (selectedFacets.containsKey(facetFields[i])) {
                        String value = selectedFacets.get(facetFields[i]);
                        lineLength = lineLength + value.length();

                        if (hasPrevious) {
                            string = string.concat(", ");
                        }

                        if (lineLength > maxLineLength) {
                            string = string.concat("\n");
                            lineLength = 0;
                            hasPrevious = false;
                        }

                        string = string.concat(value);
                        hasPrevious = true;
                    }
                    i++;
                }

                // create a new wicket multi line label
                facetOverview = new MultiLineLabel("facetOverview", string);
            }

            // finally, merge the label to the form
            this.add(facetOverview);
        }

        public SearchBoxForm(String id, SearchPageQuery query) {
            super(id, new CompoundPropertyModel<SearchPageQuery>(query));
            add(new ExternalLink("vloHomeLink", VloConfig.getHomeUrl()));

            searchBox = new AutoCompleteTextField<String>("searchQuery") {
                @Override
                protected Iterator<String> getChoices(String input) {
                    return autoCompleteDao.getChoices(input).iterator();
                }
            };

            add(searchBox);
            Button submit = new Button("searchSubmit");
            add(submit);

            // merge link to help menu page 
            String helpUrl = VloConfig.getHelpUrl();
            ExternalLink helpLink = new ExternalLink("helpLink", helpUrl, "help");
            add(helpLink);

            VloPageParameters param;
            param = new VloPageParameters(query.getPageParameters());

            final RequestCycle reqCycle = getRequestCycle();
            final Url reqUrl = Url.parse(reqCycle.urlFor(ShowResultPage.class, param.convert()));
            String thisURL = reqCycle.getUrlRenderer().renderFullUrl(reqUrl);

            try {
                thisURL = URLEncoder.encode(thisURL, "UTF-8");
            } catch (UnsupportedEncodingException e) {
            }

            String feedbackFormUrl = VloConfig.getFeedbackFromUrl() + thisURL;
            ExternalLink feedbackLink = new ExternalLink("feedbackLink", feedbackFormUrl, "found an error?");
            add(feedbackLink);

            addFacetOverview();
        }

        @Override
        protected void onSubmit() {
            SearchPageQuery query = getModelObject();
            PageParameters param = query.getPageParameters();

            VloPageParameters newParam = new VloPageParameters();

            setResponsePage(FacetedSearchPage.class, newParam);
        }
    }

    private void addSearchBox() {
        add(new SearchBoxForm("searchForm", query));
    }

    @SuppressWarnings("serial")
    private void addFacetColumns() {
        GridView<FacetField> facetColumns = new GridView<FacetField>("facetColumns", (IDataProvider<FacetField>) new SolrFacetDataProvider(query.getSolrQuery()
                .getCopy())) {
                    @Override
                    protected void populateItem(Item<FacetField> item) {
                        String facetName = ((FacetField) item.getDefaultModelObject()).getName();
                        String descriptionTooltip = "";
                        if (facetNameMap.containsKey(facetName)) {
                            descriptionTooltip = facetNameMap.get(facetName).getDescription();
                        }
                        item.add(new FacetBoxPanel("facetBox", item.getModel(), descriptionTooltip).create(query));
                    }

                    @Override
                    protected void populateEmptyItem(Item<FacetField> item) {
                        item.add(new Label("facetBox", ""));
                    }
                };
        facetColumns.setColumns(2);
        add(facetColumns);
    }

    @SuppressWarnings("serial")
    private void addSearchResults() {
        List<IColumn<SolrDocument, String>> columns;
        columns = new ArrayList<IColumn<SolrDocument, String>>();
        columns.add(new AbstractColumn<SolrDocument, String>(new ResourceModel(Resources.NAME)) {

            @Override
            public void populateItem(Item<ICellPopulator<SolrDocument>> cellItem, String componentId, IModel<SolrDocument> rowModel) {
                cellItem.add(new DocumentLinkPanel(componentId, rowModel, query));
            }
        });
        columns.add(new AbstractColumn<SolrDocument, String>(new ResourceModel(Resources.DESCRIPTION)) {

            @Override
            public void populateItem(Item<ICellPopulator<SolrDocument>> cellItem, String componentId, IModel<SolrDocument> rowModel) {
                String descriptionText = (String) rowModel.getObject().getFirstValue(FacetConstants.FIELD_DESCRIPTION);
                cellItem.add(new TruncatedLabel(componentId, 100, descriptionText));
            }
        });
        AjaxFallbackDefaultDataTable<SolrDocument, String> searchResultList = new AjaxFallbackDefaultDataTable<SolrDocument, String>("searchResults", columns, (ISortableDataProvider<SolrDocument, String>) new SolrDocumentDataProvider(query.getSolrQuery().getCopy()), 30);

        add(searchResultList);
    }

    /**
     * Add contentSearch form (FCS)
     *
     * @param solrDocument
     */
    private void addSearchServiceForm() {

        BookmarkablePageLink link;
        link = new BookmarkablePageLink("link", FacetedSearchPage.class);
        link.add(new Label("naar deze pagina"));

        // get values for cql endpoint substitution
        String cqlEndpointFilter = VloConfig.getCqlEndpointFilter();
        String cqlEndpointAlternative = VloConfig.getCqlEndpointAlternative();

        final WebMarkupContainer contentSearchContainer = new WebMarkupContainer("contentSearch");
        add(contentSearchContainer);

        // get all documents with an entry for the FCS
        SearchServiceDataProvider dataProvider = new SearchServiceDataProvider(query.getSolrQuery());
        if (dataProvider.size() > 0 && dataProvider.size() <= 200) {    // at least one and not more than x records with FCS endpoint in result set?
            try {
                // building map (CQL endpoint -> List of resource IDs)
                HashMap<String, List<String>> aggregationContextMap = new HashMap<String, List<String>>();

                int offset = 0;
                int fetchSize = 1000;
                int totalResults = (int) dataProvider.size();
                while (offset < totalResults) {
                    Iterator<SolrDocument> iter = dataProvider.iterator(offset, fetchSize);
                    while (iter.hasNext()) {
                        SolrDocument document = iter.next();
                        String id = document.getFirstValue(FacetConstants.FIELD_ID).toString();
                        String fcsEndpoint = document.getFirstValue(FacetConstants.FIELD_SEARCH_SERVICE).toString();
                        if (aggregationContextMap.containsKey(fcsEndpoint)) {
                            aggregationContextMap.get(fcsEndpoint).add(id);
                        } else {
                            List<String> idArray = new ArrayList<String>();
                            idArray.add(id);

                            // substitute endpoint
                            if (cqlEndpointFilter.length() == 0) {
                                // no substitution
                            } else {
                                // check for the need to substitute
                            }

                            if (cqlEndpointFilter.equals(cqlEndpointFilter)) {
                                // no substitution, take the value from the record
                                aggregationContextMap.put(fcsEndpoint, idArray);
                            } else {
                                // substitution, take the alternative url
                                aggregationContextMap.put(cqlEndpointAlternative, idArray);
                            }
                        }
                    }

                    offset += fetchSize;
                }

                // merge HTML form to container
                String labelString;
                if (totalResults == 1) {
                    labelString = "Plain text search via Federated Content Search (supported by one resource in this result set)";
                } else {
                    labelString = "Plain text search via Federated Content Search (supported by " + totalResults
                            + " resources in this result set)";
                }
                Label contentSearchLabel = new Label("contentSearchForm", HtmlFormCreator.getContentSearchForm(
                        aggregationContextMap, labelString));
                contentSearchLabel.setEscapeModelStrings(false);
                contentSearchContainer.add(contentSearchLabel);
                // contentSearchContainer.merge(link);
            } catch (UnsupportedEncodingException uee) {
                contentSearchContainer.setVisible(false);
            }
        } else {
            contentSearchContainer.setVisible(false);
        }
    }
}