001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.pluto.internal.impl;
018:
019: import java.util.ArrayList;
020: import java.util.Iterator;
021: import java.util.List;
022:
023: import javax.portlet.PreferencesValidator;
024: import javax.portlet.ValidatorException;
025: import javax.servlet.ServletContext;
026:
027: import org.apache.commons.logging.Log;
028: import org.apache.commons.logging.LogFactory;
029: import org.apache.pluto.PortletContainerException;
030: import org.apache.pluto.descriptors.portlet.PortletAppDD;
031: import org.apache.pluto.descriptors.portlet.PortletDD;
032: import org.apache.pluto.descriptors.portlet.PortletPreferenceDD;
033: import org.apache.pluto.descriptors.portlet.PortletPreferencesDD;
034: import org.apache.pluto.descriptors.servlet.ServletDD;
035: import org.apache.pluto.internal.InternalPortletPreference;
036: import org.apache.pluto.internal.PortletDescriptorRegistry;
037: import org.apache.pluto.internal.PortletEntity;
038: import org.apache.pluto.internal.PreferencesValidatorRegistry;
039:
040: /**
041: * The PortletEntity encapsulates all data pertaining to a single portlet
042: * instance. This instance may appear zero or more times per user. The
043: * PortletEntity consists of two primary peices of information, the Portlet
044: * Definition as defined by the {@link PortletDD} and the Wrapping Servlet
045: * information as defined by the{@link ServletDD}
046: *
047: */
048: public class PortletEntityImpl implements PortletEntity {
049:
050: /** Logger. */
051: private static final Log LOG = LogFactory
052: .getLog(PortletEntityImpl.class);
053:
054: /** URI prefix of the portlet invoker servlet. */
055: private static final String PREFIX = "/PlutoInvoker/";
056:
057: // Private Member Variables ------------------------------------------------
058:
059: /** The servlet context. */
060: private final ServletContext servletContext;
061:
062: /** The portlet window. */
063: private final String portletName;
064:
065: /** The cached PortletDD retrieved from the portlet descriptor registry. */
066: private PortletDD portletDefinition;
067:
068: /** Default portlet preferences defined for this portlet. */
069: private InternalPortletPreference[] defaultPreferences;
070:
071: // Constructor -------------------------------------------------------------
072:
073: PortletEntityImpl(ServletContext servletContext, String portletName) {
074: this .servletContext = servletContext;
075: this .portletName = portletName;
076: }
077:
078: // PortletEntity Impl ------------------------------------------------------
079:
080: /**
081: * Returns the URI to the controller servlet that wraps this portlet.
082: * @return the URI to the controller servlet that wraps this portlet.
083: * @deprecated
084: */
085: public String getControllerServletUri() {
086: // this method is deprecated as of pluto 1.1.2, so that
087: // we can remove it in the future. The PortletInvokerService
088: // will be responsible for resolving the URI used to invoke
089: // the portlet.
090: return PREFIX + portletName;
091: }
092:
093: /**
094: * Returns an array of default preferences of this portlet. The default
095: * preferences are retrieved from the portlet application descriptor.
096: * <p>
097: * Data retrieved from <code>portlet.xml</code> are injected into the domain
098: * object <code>PortletPreferenceDD</code>. This method converts the domain
099: * objects into <code>PortletPreference</code> objects.
100: * </p>
101: * <p>
102: * Note that if no value is bound to a given preference key,
103: * <code>PortletPreferenceDD.getValues()</code> will return an empty string
104: * list, but the value array of <code>PortletPreference</code> should be set
105: * to null (instead of an empty array).
106: * </p>
107: * <p>
108: * This method never returns null, but the values held by PortletPreference
109: * may be null.
110: * </p>
111: * @return the preference set
112: *
113: * @see org.apache.pluto.descriptors.portlet.PortletPreferenceDD
114: */
115: public InternalPortletPreference[] getDefaultPreferences() {
116: if (defaultPreferences == null) {
117: PortletDD portletDD = getPortletDefinition();
118: PortletPreferencesDD prefsDD = portletDD
119: .getPortletPreferences();
120: if (prefsDD != null) {
121: List prefs = new ArrayList();
122: for (Iterator it = prefsDD.getPortletPreferences()
123: .iterator(); it.hasNext();) {
124: PortletPreferenceDD prefDD = (PortletPreferenceDD) it
125: .next();
126: String[] values = null;
127: if (prefDD.getValues().size() > 0) {
128: values = (String[]) prefDD.getValues().toArray(
129: new String[prefDD.getValues().size()]);
130: }
131: PortletPreferenceImpl pref = new PortletPreferenceImpl(
132: prefDD.getName(), values, prefDD
133: .isReadOnly());
134: prefs.add(pref);
135: }
136: defaultPreferences = (InternalPortletPreference[]) prefs
137: .toArray(new InternalPortletPreference[prefs
138: .size()]);
139: }
140: }
141: return defaultPreferences;
142: }
143:
144: /**
145: * Returns the portlet description. The return value cannot be NULL.
146: * @return the portlet description.
147: */
148: public PortletDD getPortletDefinition() {
149: if (portletDefinition == null) {
150: load();
151: }
152: return portletDefinition;
153: }
154:
155: /**
156: * Returns the preferences validator instance for this portlet.
157: * One validator instance is created per portlet definition.
158: * @return the preferences validator instance for this portlet.
159: * @throws ValidatorException if fail to instantiate the validator.
160: */
161: public PreferencesValidator getPreferencesValidator()
162: throws ValidatorException {
163: PreferencesValidator validator = PreferencesValidatorRegistry
164: .getRegistry().getPreferencesValidator(
165: getPortletDefinition());
166: return validator;
167: }
168:
169: // Private Methods ---------------------------------------------------------
170:
171: /**
172: * Loads the portlet definition.
173: */
174: private void load() {
175:
176: // Retrieve the cross servlet context for the portlet.
177: ServletContext crossContext = servletContext;
178: if (LOG.isDebugEnabled()) {
179: LOG.debug("Retrieved cross context: " + crossContext);
180: }
181:
182: // Load PortletAppDD and find out the portlet definition.
183: try {
184: PortletAppDD appDD = PortletDescriptorRegistry
185: .getRegistry().getPortletAppDD(crossContext);
186: for (Iterator it = appDD.getPortlets().iterator(); it
187: .hasNext();) {
188: PortletDD portletDD = (PortletDD) it.next();
189: if (portletDD.getPortletName().equals(portletName)) {
190: portletDefinition = portletDD;
191: break;
192: }
193: }
194: } catch (PortletContainerException ex) {
195: String message = "Unable to load Portlet App Deployment Descriptor:"
196: + ex.getMessage();
197: LOG.error(message, ex);
198: // FIXME: should this be a NullPointerException?
199: throw new NullPointerException(message);
200: }
201: }
202:
203: }
|