Application: gvSIG desktop

package org.gvsig.propertypage.impl;

import java.awt.event.ActionEvent;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.propertypage.PropertiesPage;

import org.gvsig.propertypage.PropertiesPage.SetPageEnabledEvent;

import org.gvsig.propertypage.PropertiesPageFactory;

import org.gvsig.propertypage.PropertiesPageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.identitymanagement.SimpleIdentity;

import org.gvsig.tools.identitymanagement.SimpleIdentityManager;

import org.gvsig.tools.util.Invocable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultPropertiesPageManager implements PropertiesPageManager {

    private static class DefaultSetPageEnabledEvent extends ActionEvent {

        private Invocable filter;

        private boolean enabled;

        public DefaultSetPageEnabledEvent(Object source, Invocable filter, boolean enabled ) {

            super(source, SetPageEnabledEvent.ID, SetPageEnabledEvent.ACTION_COMMAND);

            this.filter = filter;

            this.enabled = enabled;

        }

        public Invocable getFilter() {

            return filter;

        }

        public boolean isEnabled() {

            return enabled;

        }

    }

    public static final String ACCESS_PAGE_AUTHORIZATION = "propertypage-access";

    private static final Logger logger = LoggerFactory.getLogger(DefaultPropertiesPageManager.class);

    private final Map<String, Map<String, PropertiesPageFactory>> groups = new HashMap<>();

    public DefaultPropertiesPageManager() {

    }

    private String getFactoryName(PropertiesPageFactory factory) {

        String factoryName = factory.getClass().getName();

        try {

            factoryName = factory.getName();

        } catch(Throwable ex) {

        }

        return factoryName;

    }

    @Override

    public void registerFactory(PropertiesPageFactory factory) {

        logger.info("Register PropertisPageFactory " + factory.getClass().getName() + " , groupID=" + factory.getGroupID() + " (" + factory.toString() + ").");

        Map<String, PropertiesPageFactory> group = this.getFactories(factory.getGroupID());

        group.put(getFactoryName(factory), factory);

    }

    private Map<String, PropertiesPageFactory> getFactories(String groupID) {

        logger.info("get propeties page factories for groupID '" + groupID + "'");

        Map<String,PropertiesPageFactory> group = this.groups.get(groupID);

        if (group == null) {

            group = new HashMap<>();

            this.groups.put(groupID, group);

        }

        return group;

    }

    @Override

    public List<PropertiesPage> getPages(String groupID, Object obj) {

        logger.info("get propeties page for groupID '" + groupID + "', and object '" + obj.toString() + "'.");

        List<PropertiesPage> pages = new ArrayList<>();

        SimpleIdentityManager identityManager = ToolsLocator.getIdentityManager();

        SimpleIdentity currentUser = identityManager.getCurrentIdentity();

        if (!currentUser.isAuthorized(ACCESS_PAGE_AUTHORIZATION,null,groupID ) ) {

            return pages; // Empty list, no access to pages authoriced

        }

        Collection<PropertiesPageFactory> factories = this.getFactories(groupID).values();

        String authorizationId = ACCESS_PAGE_AUTHORIZATION+"-"+groupID;

        for (PropertiesPageFactory factory : factories) {

            String factoryName = getFactoryName(factory);

            try {

                if (factory.isVisible(obj)) {

                    PropertiesPage page = factory.create(obj);

                    if (currentUser.isAuthorized(authorizationId,page, page.getTitle()) ) {

                        pages.add(page);

                    }

                }

            } catch(Throwable ex) {

                logger.warn("Can't get properties page from factory '"+factoryName+"'.",ex);

            }

        }

        Collections.sort(pages, new Comparator<PropertiesPage>() {

            @Override

            public int compare(PropertiesPage f1, PropertiesPage f2) {

                int n = f2.getPriority() - f1.getPriority();

                if (n != 0) {

                    return n;

                }

                if (f1.getTitle() == null || f2.getTitle() == null) {

                    // Mas que nada para que no pete, y aunque el orden

                    // no sea correcto muestre algo al usuario.

                    return 0;

                }

                return f1.getTitle().compareTo(f2.getTitle());

            }

        });

        return pages;

    }

    @Override

    public ActionEvent createSetPageEnableEvent(PropertiesPage source, Invocable filter, boolean enabled) {

        return new DefaultSetPageEnabledEvent(source, filter, enabled);

    }

    @Override

    public ActionEvent createSetPageEnableEvent(final PropertiesPage source, final Class filterClass, final boolean enabled) {

        return new DefaultSetPageEnabledEvent(

                source, 

                new Invocable() {

                    @Override

                    public Object call(Object... propertiesPages) {

                        return filterClass.isInstance(propertiesPages[0]);

                    }

                }, 

                enabled

        );

    }

}