| /* | |
| * Licensed to the Apache Software Foundation (ASF) under one or more | |
| * contributor license agreements. See the NOTICE file distributed with | |
| * this work for additional information regarding copyright ownership. | |
| * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| * (the "License"); you may not use this file except in compliance with | |
| * the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| */ | |
| package org.apache.lenya.cms.usecase.gui.impl; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import org.apache.avalon.framework.configuration.Configurable; | |
| import org.apache.avalon.framework.configuration.Configuration; | |
| import org.apache.avalon.framework.configuration.ConfigurationException; | |
| import org.apache.avalon.framework.context.Context; | |
| import org.apache.avalon.framework.context.ContextException; | |
| import org.apache.avalon.framework.context.Contextualizable; | |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; | |
| import org.apache.avalon.framework.service.ServiceException; | |
| import org.apache.avalon.framework.service.ServiceManager; | |
| import org.apache.avalon.framework.service.ServiceSelector; | |
| import org.apache.avalon.framework.service.Serviceable; | |
| import org.apache.cocoon.components.ContextHelper; | |
| import org.apache.cocoon.environment.Request; | |
| import org.apache.lenya.ac.AccessControlException; | |
| import org.apache.lenya.ac.AccessController; | |
| import org.apache.lenya.ac.AccessControllerResolver; | |
| import org.apache.lenya.ac.Authorizer; | |
| import org.apache.lenya.ac.Role; | |
| import org.apache.lenya.cms.ac.PolicyUtil; | |
| import org.apache.lenya.cms.ac.usecase.UsecaseAuthorizer; | |
| import org.apache.lenya.cms.cocoon.components.context.ContextUtility; | |
| import org.apache.lenya.cms.publication.DocumentFactory; | |
| import org.apache.lenya.cms.publication.DocumentUtil; | |
| import org.apache.lenya.cms.publication.Publication; | |
| import org.apache.lenya.cms.publication.PublicationUtil; | |
| import org.apache.lenya.cms.usecase.Usecase; | |
| import org.apache.lenya.cms.usecase.UsecaseMessage; | |
| import org.apache.lenya.cms.usecase.UsecaseResolver; | |
| import org.apache.lenya.cms.usecase.gui.GUIManager; | |
| import org.apache.lenya.cms.usecase.gui.Tab; | |
| import org.apache.lenya.util.ServletHelper; | |
| /** | |
| * GUI manager implementation. | |
| */ | |
| public class GUIManagerImpl extends AbstractLogEnabled implements GUIManager, Configurable, | |
| Serviceable, Contextualizable { | |
| protected static final String ELEMENT_PARAMETER = "parameter"; | |
| protected static final String ELEMENT_TAB_GROUP = "tab-group"; | |
| protected static final String ELEMENT_TAB = "tab"; | |
| protected static final String ATTRIBUTE_NAME = "name"; | |
| protected static final String ATTRIBUTE_VALUE = "value"; | |
| protected static final String ATTRIBUTE_LABEL = "label"; | |
| protected static final String ATTRIBUTE_USECASE = "usecase"; | |
| private Map name2group = new HashMap(); | |
| /** | |
| * @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration) | |
| */ | |
| public void configure(Configuration config) throws ConfigurationException { | |
| Configuration[] tabGroupConfigs = config.getChildren(ELEMENT_TAB_GROUP); | |
| for (int i = 0; i < tabGroupConfigs.length; i++) { | |
| String groupName = tabGroupConfigs[i].getAttribute(ATTRIBUTE_NAME); | |
| List group = new ArrayList(); | |
| Configuration[] tabConfigs = tabGroupConfigs[i].getChildren(ELEMENT_TAB); | |
| for (int j = 0; j < tabConfigs.length; j++) { | |
| String name = tabConfigs[j].getAttribute(ATTRIBUTE_NAME); | |
| String label = tabConfigs[j].getAttribute(ATTRIBUTE_LABEL); | |
| String usecase = tabConfigs[j].getAttribute(ATTRIBUTE_USECASE); | |
| TabImpl tab = new TabImpl(groupName, name, usecase, label); | |
| group.add(tab); | |
| Configuration[] paramConfigs = tabConfigs[j].getChildren(ELEMENT_PARAMETER); | |
| for (int p = 0; p < paramConfigs.length; p++) { | |
| String paramName = paramConfigs[p].getAttribute(ATTRIBUTE_NAME); | |
| String paramValue = paramConfigs[p].getAttribute(ATTRIBUTE_VALUE); | |
| tab.setParameter(paramName, paramValue); | |
| } | |
| } | |
| name2group.put(groupName, group.toArray(new Tab[group.size()])); | |
| } | |
| } | |
| /** | |
| * @see org.apache.lenya.cms.usecase.gui.GUIManager#getActiveTabs(java.lang.String) | |
| */ | |
| public Tab[] getActiveTabs(String group) { | |
| Tab[] tabs = getTabs(group); | |
| List activeTabs = new ArrayList(); | |
| for (int i = 0; i < tabs.length; i++) { | |
| if (getErrorMessages(tabs[i]).length == 0) { | |
| activeTabs.add(tabs[i]); | |
| } | |
| } | |
| return (Tab[]) activeTabs.toArray(new Tab[activeTabs.size()]); | |
| } | |
| protected Tab[] getTabs(String group) { | |
| Tab[] tabs = (Tab[]) name2group.get(group); | |
| return tabs; | |
| } | |
| /** | |
| * @see org.apache.lenya.cms.usecase.gui.GUIManager#getTab(java.lang.String, java.lang.String) | |
| */ | |
| public Tab getTab(String group, String name) { | |
| Tab[] tabs = getTabs(group); | |
| for (int i = 0; i < tabs.length; i++) { | |
| if (name.equals(tabs[i].getName())) { | |
| return tabs[i]; | |
| } | |
| } | |
| throw new IllegalArgumentException("No tab [" + name + "] in group [" + group + "]"); | |
| } | |
| /** | |
| * Checks if a tab's usecase can be executed. | |
| * @param tab The tab. | |
| * @return An array of error messages. | |
| */ | |
| protected UsecaseMessage[] getErrorMessages(Tab tab) { | |
| UsecaseMessage[] messages; | |
| ServiceSelector selector = null; | |
| AccessControllerResolver acResolver = null; | |
| AccessController accessController = null; | |
| UsecaseResolver usecaseResolver = null; | |
| UsecaseAuthorizer authorizer = null; | |
| try { | |
| selector = (ServiceSelector) this.manager.lookup(AccessControllerResolver.ROLE | |
| + "Selector"); | |
| acResolver = (AccessControllerResolver) selector.select(AccessControllerResolver.DEFAULT_RESOLVER); | |
| accessController = acResolver.resolveAccessController(this.webappUrl); | |
| Authorizer[] authorizers = accessController.getAuthorizers(); | |
| for (int i = 0; i < authorizers.length; i++) { | |
| if (authorizers[i] instanceof UsecaseAuthorizer) { | |
| authorizer = (UsecaseAuthorizer) authorizers[i]; | |
| } | |
| } | |
| usecaseResolver = (UsecaseResolver) this.manager.lookup(UsecaseResolver.ROLE); | |
| // filter item if usecase not allowed | |
| if (tab.getUsecase() != null) { | |
| if (getLogger().isDebugEnabled()) { | |
| getLogger().debug("Found usecase [" + tab.getUsecase() + "]"); | |
| } | |
| DocumentFactory factory; | |
| ContextUtility util = null; | |
| try { | |
| util = (ContextUtility) this.manager.lookup(ContextUtility.ROLE); | |
| Request request = util.getRequest(); | |
| factory = DocumentUtil.getDocumentFactory(this.manager, request); | |
| } finally { | |
| if (util != null) { | |
| this.manager.release(util); | |
| } | |
| } | |
| Publication pub = PublicationUtil.getPublicationFromUrl(this.manager, | |
| factory, | |
| this.webappUrl); | |
| if (!authorizer.authorizeUsecase(tab.getUsecase(), this.roles, pub)) { | |
| if (getLogger().isDebugEnabled()) { | |
| getLogger().debug("Usecase not authorized"); | |
| } | |
| messages = new UsecaseMessage[1]; | |
| messages[0] = new UsecaseMessage("Access denied"); | |
| } | |
| } | |
| if (usecaseResolver.isRegistered(this.webappUrl, tab.getUsecase())) { | |
| Usecase usecase = null; | |
| try { | |
| usecase = usecaseResolver.resolve(this.webappUrl, tab.getUsecase()); | |
| usecase.setSourceURL(this.webappUrl); | |
| usecase.setName(tab.getUsecase()); | |
| String[] keys = tab.getParameterNames(); | |
| for (int i = 0; i < keys.length; i++) { | |
| usecase.setParameter(keys[i], tab.getParameter(keys[i])); | |
| } | |
| usecase.checkPreconditions(); | |
| if (usecase.hasErrors()) { | |
| if (getLogger().isDebugEnabled()) { | |
| getLogger().debug("Usecase preconditions not complied"); | |
| } | |
| List msgs = usecase.getErrorMessages(); | |
| messages = (UsecaseMessage[]) msgs.toArray(new UsecaseMessage[msgs.size()]); | |
| } else { | |
| messages = new UsecaseMessage[0]; | |
| } | |
| } finally { | |
| if (usecase != null) { | |
| usecaseResolver.release(usecase); | |
| } | |
| } | |
| } else { | |
| messages = new UsecaseMessage[1]; | |
| messages[0] = new UsecaseMessage("Usecase [" + tab.getUsecase() | |
| + "] is not registered!", null); | |
| } | |
| } catch (final Exception e) { | |
| throw new RuntimeException(e); | |
| } finally { | |
| if (usecaseResolver != null) { | |
| this.manager.release(usecaseResolver); | |
| } | |
| if (selector != null) { | |
| if (acResolver != null) { | |
| if (accessController != null) { | |
| acResolver.release(accessController); | |
| } | |
| selector.release(acResolver); | |
| } | |
| this.manager.release(selector); | |
| } | |
| } | |
| return messages; | |
| } | |
| private ServiceManager manager; | |
| /** | |
| * @see org.apache.avalon.framework.service.Serviceable#service(org.apache.avalon.framework.service.ServiceManager) | |
| */ | |
| public void service(ServiceManager manager) throws ServiceException { | |
| this.manager = manager; | |
| } | |
| private String webappUrl; | |
| private Role[] roles; | |
| /** | |
| * @see org.apache.avalon.framework.context.Contextualizable#contextualize(org.apache.avalon.framework.context.Context) | |
| */ | |
| public void contextualize(Context context) throws ContextException { | |
| Request request = ContextHelper.getRequest(context); | |
| try { | |
| this.roles = PolicyUtil.getRoles(request); | |
| } catch (AccessControlException e) { | |
| throw new ContextException("Obtaining roles failed: ", e); | |
| } | |
| this.webappUrl = ServletHelper.getWebappURI(request); | |
| } | |
| } |