001: /******************************************************************************
002: * JBoss, a division of Red Hat *
003: * Copyright 2006, Red Hat Middleware, LLC, and individual *
004: * contributors as indicated by the @authors tag. See the *
005: * copyright.txt in the distribution for a full listing of *
006: * individual contributors. *
007: * *
008: * This is free software; you can redistribute it and/or modify it *
009: * under the terms of the GNU Lesser General Public License as *
010: * published by the Free Software Foundation; either version 2.1 of *
011: * the License, or (at your option) any later version. *
012: * *
013: * This software is distributed in the hope that it will be useful, *
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of *
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
016: * Lesser General Public License for more details. *
017: * *
018: * You should have received a copy of the GNU Lesser General Public *
019: * License along with this software; if not, write to the Free *
020: * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *
021: * 02110-1301 USA, or see the FSF site: http://www.fsf.org. *
022: ******************************************************************************/package org.jboss.portal.core.admin.ui;
023:
024: import org.jboss.portal.common.i18n.LocalizedString;
025: import org.jboss.portal.common.util.IteratorStatus;
026: import org.jboss.portal.common.util.MediaType;
027: import org.jboss.portal.core.impl.model.content.ContentProviderRegistryService;
028: import org.jboss.portal.core.model.content.ContentType;
029: import org.jboss.portal.core.model.content.spi.portlet.ContentPortlet;
030: import org.jboss.portal.core.model.instance.Instance;
031: import org.jboss.portal.core.model.portal.PortalObject;
032: import org.jboss.portal.core.model.portal.PortalObjectId;
033: import org.jboss.portal.core.model.portal.PortalObjectPath;
034: import org.jboss.portal.core.portlet.info.CorePortletInfo;
035: import org.jboss.portal.core.portlet.info.PortletIconInfo;
036: import org.jboss.portal.core.portlet.info.PortletInfoInfo;
037: import org.jboss.portal.core.ui.content.portlet.PortletContentEditorPortlet;
038: import org.jboss.portal.faces.el.DelegatingPropertyResolver;
039: import org.jboss.portal.faces.el.decorator.AbstractBeanDecorator;
040: import org.jboss.portal.faces.el.decorator.AbstractPropertyDecorator;
041: import org.jboss.portal.faces.el.decorator.PropertyDecorator;
042: import org.jboss.portal.faces.el.decorator.SimpleBeanDecorator;
043: import org.jboss.portal.identity.IdentityException;
044: import org.jboss.portal.identity.RoleModule;
045: import org.jboss.portal.portlet.Portlet;
046: import org.jboss.portal.portlet.PortletInvokerException;
047: import org.jboss.portal.portlet.info.MetaInfo;
048: import org.jboss.portal.portlet.info.PortletInfo;
049: import org.jboss.portal.security.AuthorizationDomainRegistry;
050: import org.jboss.portal.security.spi.provider.AuthorizationDomain;
051: import org.jboss.portal.theme.LayoutService;
052: import org.jboss.portal.theme.PortalLayout;
053: import org.jboss.portal.theme.PortalRenderSet;
054: import org.jboss.portal.theme.PortalTheme;
055: import org.jboss.portal.theme.ServerRegistrationID;
056: import org.jboss.portal.theme.ThemeService;
057:
058: import javax.faces.context.FacesContext;
059: import javax.faces.el.PropertyResolver;
060: import javax.faces.model.SelectItem;
061: import java.util.ArrayList;
062: import java.util.Collection;
063: import java.util.Collections;
064: import java.util.HashMap;
065: import java.util.Iterator;
066: import java.util.List;
067: import java.util.Locale;
068: import java.util.Map;
069: import java.util.Set;
070:
071: /**
072: * @author <a href="mailto:julien@jboss.org">Julien Viet</a>
073: * @version $Revision: 9347 $
074: */
075: public class AdminPropertyResolver extends DelegatingPropertyResolver {
076: public AdminPropertyResolver() {
077: init();
078: }
079:
080: public AdminPropertyResolver(PropertyResolver delegate) {
081: super (delegate);
082:
083: //
084: init();
085: }
086:
087: private void init() {
088: SimpleBeanDecorator roleModuleDecorator = new SimpleBeanDecorator();
089: roleModuleDecorator.setProperty("roles",
090: new AbstractPropertyDecorator(Set.class) {
091: public Object getValue(Object bean) {
092: try {
093: RoleModule module = (RoleModule) bean;
094: return module.findRoles();
095: } catch (IdentityException e) {
096: e.printStackTrace();
097: return null;
098: }
099: }
100: });
101: registerDecorator(RoleModule.class, roleModuleDecorator);
102:
103: //
104: SimpleBeanDecorator localizedStringDecorator = new SimpleBeanDecorator();
105: localizedStringDecorator.setProperty("value",
106: new AbstractPropertyDecorator(String.class) {
107: public Object getValue(Object bean) {
108: LocalizedString string = (LocalizedString) bean;
109: return getValueForRequestLocale(string);
110: }
111: });
112: registerDecorator(LocalizedString.class,
113: localizedStringDecorator);
114:
115: //
116: SimpleBeanDecorator portletDecorator = new SimpleBeanDecorator();
117: portletDecorator.setProperty("name",
118: new AbstractPropertyDecorator(String.class) {
119: public Object getValue(Object bean)
120: throws IllegalArgumentException {
121: Portlet portlet = (Portlet) bean;
122: String displayName = getValueForRequestLocale(portlet
123: .getInfo().getMeta().getMetaValue(
124: MetaInfo.DISPLAY_NAME));
125:
126: return displayName != null ? displayName
127: : portlet.getContext().getId();
128: }
129: });
130: portletDecorator.setProperty("description",
131: new AbstractPropertyDecorator(LocalizedString.class) {
132: public Object getValue(Object bean)
133: throws IllegalArgumentException {
134: Portlet portlet = (Portlet) bean;
135: return portlet.getInfo().getMeta()
136: .getMetaValue(MetaInfo.DESCRIPTION);
137: }
138: });
139: portletDecorator.setProperty("keywords",
140: new AbstractPropertyDecorator(LocalizedString.class) {
141: public Object getValue(Object bean)
142: throws IllegalArgumentException {
143: Portlet portlet = (Portlet) bean;
144: return portlet.getInfo().getMeta()
145: .getMetaValue(MetaInfo.KEYWORDS);
146: }
147: });
148: portletDecorator.setProperty("title",
149: new AbstractPropertyDecorator(LocalizedString.class) {
150: public Object getValue(Object bean)
151: throws IllegalArgumentException {
152: Portlet portlet = (Portlet) bean;
153: return portlet.getInfo().getMeta()
154: .getMetaValue(MetaInfo.TITLE);
155: }
156: });
157: portletDecorator.setProperty("remotable",
158: new AbstractPropertyDecorator(Boolean.class) {
159: public Object getValue(Object bean)
160: throws IllegalArgumentException {
161: Portlet portlet = (Portlet) bean;
162: PortletInfo info = portlet.getInfo();
163: return info.isRemotable();
164: }
165: });
166: portletDecorator.setProperty("modes",
167: new AbstractPropertyDecorator(Set.class) {
168: public Object getValue(Object bean)
169: throws IllegalArgumentException {
170: Portlet portlet = (Portlet) bean;
171: return portlet.getInfo().getCapabilities()
172: .getModes("text/html");
173: }
174: });
175: portletDecorator.setProperty("windowStates",
176: new AbstractPropertyDecorator(Set.class) {
177: public Object getValue(Object bean)
178: throws IllegalArgumentException {
179: Portlet portlet = (Portlet) bean;
180: return portlet.getInfo().getCapabilities()
181: .getWindowStates("text/html");
182: }
183: });
184: portletDecorator.setProperty("locales",
185: new AbstractPropertyDecorator(Set.class) {
186: public Object getValue(Object bean)
187: throws IllegalArgumentException {
188: Portlet portlet = (Portlet) bean;
189: return new ArrayList(portlet.getInfo()
190: .getCapabilities().getAllLocales());
191: }
192: });
193: portletDecorator
194: .setProperty("smallIconLocation",
195: new PortletIconPropertyDecorator(
196: PortletIconInfo.SMALL));
197: portletDecorator
198: .setProperty("largeIconLocation",
199: new PortletIconPropertyDecorator(
200: PortletIconInfo.LARGE));
201: registerDecorator(Portlet.class, portletDecorator);
202:
203: //
204: SimpleBeanDecorator instanceDecorator = new SimpleBeanDecorator();
205: instanceDecorator.setProperty("portlet",
206: new AbstractPropertyDecorator(Portlet.class) {
207: public Object getValue(Object bean) {
208: Instance instance = (Instance) bean;
209: try {
210: return instance.getPortlet();
211: } catch (PortletInvokerException e) {
212: // If the portlet is not available we want to avoid the stack trace and rather return null
213: return null;
214: }
215: }
216: });
217: instanceDecorator.setProperty("displayName",
218: new InstanceDisplayNamePropertyDecorator());
219: registerDecorator(Instance.class, instanceDecorator);
220:
221: //
222: SimpleBeanDecorator portalObjectDecorator = new SimpleBeanDecorator() {
223: private List getChildren(PortalObject object, int mask) {
224: return new ArrayList(object.getChildren(mask));
225: }
226:
227: {
228: setProperty("portals", new AbstractPropertyDecorator(
229: List.class) {
230: public Object getValue(Object bean) {
231: PortalObject object = (PortalObject) bean;
232: PortalObjectId id = object.getId();
233:
234: // We don't want to iterate the potentially large collection of dashboard portals
235: if ("dashboard".equals(id.getNamespace())) {
236: return Collections.EMPTY_LIST;
237: } else {
238: return getChildren(object,
239: PortalObject.PORTAL_MASK);
240: }
241: }
242: });
243: setProperty("pages", new AbstractPropertyDecorator(
244: List.class) {
245: public Object getValue(Object bean) {
246: PortalObject object = (PortalObject) bean;
247: return getChildren(object,
248: PortalObject.PAGE_MASK);
249: }
250: });
251: setProperty("windows", new AbstractPropertyDecorator(
252: List.class) {
253: public Object getValue(Object bean) {
254: PortalObject object = (PortalObject) bean;
255: return getChildren(object,
256: PortalObject.WINDOW_MASK);
257: }
258: });
259: setProperty("maximizedStateExists",
260: new AbstractPropertyDecorator(Boolean.class) {
261: public Object getValue(Object bean) {
262: PortalObject object = (PortalObject) bean;
263: ArrayList children = new ArrayList(
264: getChildren(
265: object,
266: PortalObject.WINDOW_MASK));
267: for (IteratorStatus i = new IteratorStatus(
268: children.iterator()); i
269: .hasNext();) {
270: PortalObject portalObject = (PortalObject) i
271: .next();
272: if (portalObject
273: .getDeclaredProperties()
274: .containsValue("MAXIMIZED")) {
275: return Boolean.TRUE;
276: }
277: }
278: return Boolean.FALSE;
279: }
280: });
281: }
282: };
283: portalObjectDecorator.setProperty("id",
284: new AbstractPropertyDecorator(String.class) {
285: public Object getValue(Object bean) {
286: PortalObject object = (PortalObject) bean;
287: PortalObjectId id = object.getId();
288: return id
289: .toString(PortalObjectPath.LEGACY_BASE64_FORMAT);
290: }
291: });
292: portalObjectDecorator.setProperty("default",
293: new AbstractPropertyDecorator(Boolean.class) {
294: public Object getValue(Object bean) {
295: PortalObject object = (PortalObject) bean;
296:
297: // get the parent, if parent doesn't exist, consider the object as its own parent
298: PortalObject portalObject = object.getParent();
299: if (portalObject == null) {
300: portalObject = object;
301: }
302:
303: return Boolean
304: .valueOf(object
305: .getName()
306: .equals(
307: portalObject
308: .getDeclaredProperty(PortalObject.PORTAL_PROP_DEFAULT_OBJECT_NAME)));
309: }
310: });
311: portalObjectDecorator.setProperty("typeName",
312: new AbstractPropertyDecorator(String.class) {
313: public Object getValue(Object bean) {
314: PortalObject object = (PortalObject) bean;
315:
316: if (object != null) {
317: switch (object.getType()) {
318: case PortalObject.TYPE_CONTEXT:
319: return "context";
320: case PortalObject.TYPE_PORTAL:
321: return "portal";
322: case PortalObject.TYPE_PAGE:
323: return "page";
324: case PortalObject.TYPE_WINDOW:
325: return "window";
326: }
327: }
328:
329: //to make it safe
330: return "none";
331: }
332: });
333: registerDecorator(PortalObject.class, portalObjectDecorator);
334:
335: //
336: registerDecorator(ContentProviderRegistryService.class,
337: new AbstractBeanDecorator() {
338: protected PropertyDecorator getProperty(
339: Object propertyName) {
340: ContentType contentType = ContentType
341: .create((String) propertyName);
342: final String instanceName = ContentProviderRegistryService
343: .getInstance()
344: .getContentProvider(contentType)
345: .getPortletInfo()
346: .getPortletName(
347: ContentPortlet.EDIT_CONTENT_MODE);
348: return instanceName == null ? null
349: : new AbstractPropertyDecorator(
350: String.class) {
351: public Object getValue(Object bean)
352: throws IllegalArgumentException {
353: return instanceName;
354: }
355: };
356: }
357: });
358:
359: //
360: registerDecorator(AuthorizationDomainRegistry.class,
361: new AbstractBeanDecorator() {
362: protected PropertyDecorator getProperty(
363: final Object propertyName) {
364: return new AbstractPropertyDecorator(
365: AuthorizationDomain.class) {
366: public Object getValue(Object bean)
367: throws IllegalArgumentException {
368: return ((AuthorizationDomainRegistry) bean)
369: .getDomain((String) propertyName);
370: }
371: };
372: }
373: });
374:
375: //
376: SimpleBeanDecorator layoutServiceDecorator = new SimpleBeanDecorator();
377: layoutServiceDecorator.setProperty("layoutItems",
378: new AbstractPropertyDecorator(SelectItem[].class) {
379: public Object getValue(Object bean)
380: throws IllegalArgumentException {
381: LayoutService layoutService = (LayoutService) bean;
382: Collection layouts = layoutService.getLayouts();
383: SelectItem[] items = new SelectItem[layouts
384: .size() + 1];
385: for (IteratorStatus i = new IteratorStatus(
386: layouts.iterator()); i.hasNext();) {
387: PortalLayout layout = (PortalLayout) i
388: .next();
389: SelectItem item = new SelectItem();
390: String layoutName = layout.getLayoutInfo()
391: .getName();
392: item.setValue(layoutName);
393: item.setLabel(layoutName);
394: items[i.getIndex()] = item;
395: }
396: items[items.length - 1] = new SelectItem("",
397: "default");
398: return items;
399: }
400: });
401: layoutServiceDecorator.setProperty("renderSetItems",
402: new AbstractPropertyDecorator(SelectItem[].class) {
403: public Object getValue(Object bean)
404: throws IllegalArgumentException {
405: LayoutService layoutService = (LayoutService) bean;
406: Collection renderSets = layoutService
407: .getRenderSets();
408: Map names = new HashMap();
409: for (Iterator i = renderSets.iterator(); i
410: .hasNext();) {
411: ServerRegistrationID renderSetId = (ServerRegistrationID) i
412: .next();
413: PortalRenderSet renderSet = layoutService
414: .getRenderSet(renderSetId,
415: MediaType.HTML);
416: if (renderSet != null) {
417: names.put(renderSet.getName(),
418: renderSet.getName());
419: }
420: }
421: SelectItem[] items = new SelectItem[names
422: .size() + 1];
423: for (IteratorStatus i = new IteratorStatus(
424: names.keySet().iterator()); i.hasNext();) {
425: String key = (String) i.next();
426: items[i.getIndex()] = new SelectItem(key,
427: (String) names.get(key));
428: }
429: items[items.length - 1] = new SelectItem("",
430: "default");
431: return items;
432: }
433: });
434: registerDecorator(LayoutService.class, layoutServiceDecorator);
435:
436: //
437: SimpleBeanDecorator themeServiceDecorator = new SimpleBeanDecorator();
438: themeServiceDecorator.setProperty("themeItems",
439: new AbstractPropertyDecorator(SelectItem[].class) {
440: public Object getValue(Object bean)
441: throws IllegalArgumentException {
442: ThemeService layoutService = (ThemeService) bean;
443: Collection themes = layoutService.getThemes();
444: SelectItem[] items = new SelectItem[themes
445: .size() + 1];
446: for (IteratorStatus i = new IteratorStatus(
447: themes.iterator()); i.hasNext();) {
448: PortalTheme name = (PortalTheme) i.next();
449: SelectItem item = new SelectItem();
450: String themeName = name.getThemeInfo()
451: .getName();
452: item.setValue(themeName);
453: item.setLabel(themeName);
454: items[i.getIndex()] = item;
455: }
456: items[items.length - 1] = new SelectItem("",
457: "default");
458: return items;
459: }
460: });
461: registerDecorator(ThemeService.class, themeServiceDecorator);
462: }
463:
464: private String getValueForRequestLocale(LocalizedString string) {
465: if (string != null) {
466: FacesContext ctx = FacesContext.getCurrentInstance();
467: Locale locale = ctx.getExternalContext().getRequestLocale();
468: return string.getString(locale, true);
469: } else {
470: return null;
471: }
472: }
473:
474: private static class PortletIconPropertyDecorator extends
475: AbstractPropertyDecorator {
476: private String iconType;
477:
478: public PortletIconPropertyDecorator(String iconType) {
479: super (String.class);
480: this .iconType = iconType;
481: }
482:
483: public Object getValue(Object bean)
484: throws IllegalArgumentException {
485: Portlet portlet = (Portlet) bean;
486: PortletInfo info = portlet.getInfo();
487:
488: if (info instanceof CorePortletInfo) {
489: CorePortletInfo cInfo = (CorePortletInfo) portlet
490: .getInfo();
491: PortletInfoInfo portletInfo = cInfo.getPortletInfo();
492: if (portletInfo != null
493: && portletInfo.getPortletIconInfo() != null
494: && portletInfo.getPortletIconInfo()
495: .getIconLocation(iconType) != null) {
496: return portletInfo.getPortletIconInfo()
497: .getIconLocation(iconType);
498: }
499: }
500:
501: return PortletContentEditorPortlet.DEFAULT_PORTLET_ICON;
502: }
503: }
504:
505: private class InstanceDisplayNamePropertyDecorator extends
506: AbstractPropertyDecorator {
507: public InstanceDisplayNamePropertyDecorator() {
508: super (String.class);
509: }
510:
511: public Object getValue(Object bean)
512: throws IllegalArgumentException {
513: Instance instance = (Instance) bean;
514: String displayName = getValueForRequestLocale(instance
515: .getDisplayName());
516: if (displayName == null) {
517: displayName = instance.getId();
518: }
519: return displayName;
520: }
521: }
522:
523: }
|