org.argeo.cms/src/org/argeo/cms/util/SimpleApp.java

   1 package org.argeo.cms.util;
   2
   3 import java.io.IOException;
   4 import java.io.InputStream;
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.HashMap;
   8 import java.util.LinkedHashMap;
   9 import java.util.List;
  10 import java.util.Map;
  11
  12 import javax.jcr.Repository;
  13 import javax.jcr.RepositoryException;
  14 import javax.jcr.Session;
  15 import javax.jcr.security.Privilege;
  16 import javax.jcr.version.VersionManager;
  17
  18 import org.apache.commons.logging.Log;
  19 import org.apache.commons.logging.LogFactory;
  20 import org.argeo.cms.CmsConstants;
  21 import org.argeo.cms.CmsException;
  22 import org.argeo.cms.CmsUiProvider;
  23 import org.argeo.cms.LifeCycleUiProvider;
  24 import org.argeo.jcr.JcrUtils;
  25 import org.eclipse.gemini.blueprint.context.BundleContextAware;
  26 import org.eclipse.rap.rwt.application.Application;
  27 import org.eclipse.rap.rwt.application.Application.OperationMode;
  28 import org.eclipse.rap.rwt.application.ApplicationConfiguration;
  29 import org.eclipse.rap.rwt.application.EntryPoint;
  30 import org.eclipse.rap.rwt.application.EntryPointFactory;
  31 import org.eclipse.rap.rwt.application.ExceptionHandler;
  32 import org.eclipse.rap.rwt.client.WebClient;
  33 import org.eclipse.rap.rwt.service.ResourceLoader;
  34 import org.eclipse.swt.widgets.Composite;
  35 import org.osgi.framework.BundleContext;
  36
  37 /** A basic generic app based on {@link SimpleErgonomics}. */
  38 public class SimpleApp implements CmsConstants, ApplicationConfiguration,
  39                 BundleContextAware {
  40         private final static Log log = LogFactory.getLog(SimpleApp.class);
  41
  42         private Map<String, Map<String, String>> branding = new HashMap<String, Map<String, String>>();
  43         private Map<String, List<String>> styleSheets = new HashMap<String, List<String>>();
  44
  45         private List<String> resources = new ArrayList<String>();
  46
  47         private BundleContext bundleContext;
  48
  49         private Repository repository;
  50         private String workspace = null;
  51         private String basePath = "/";
  52         private List<String> roPrincipals = Arrays.asList("anonymous", "everyone");
  53         private List<String> rwPrincipals = Arrays.asList("everyone");
  54
  55         private CmsUiProvider header;
  56         private Map<String, CmsUiProvider> pages = new LinkedHashMap<String, CmsUiProvider>();
  57
  58         private Integer headerHeight = 40;
  59
  60         public void configure(Application application) {
  61                 try {
  62                         StyleSheetResourceLoader styleSheetRL = new StyleSheetResourceLoader(
  63                                         bundleContext);
  64                         BundleResourceLoader bundleRL = new BundleResourceLoader(
  65                                         bundleContext);
  66
  67                         application.setOperationMode(OperationMode.SWT_COMPATIBILITY);
  68                         // application.setOperationMode(OperationMode.JEE_COMPATIBILITY);
  69
  70                         application.setExceptionHandler(new CmsExceptionHandler());
  71
  72                         // loading animated gif
  73                         application.addResource(LOADING_IMAGE,
  74                                         createResourceLoader(LOADING_IMAGE));
  75                         // empty image
  76                         application.addResource(NO_IMAGE, createResourceLoader(NO_IMAGE));
  77
  78                         for (String resource : resources) {
  79                                 application.addResource(resource, bundleRL);
  80                                 if (log.isDebugEnabled())
  81                                         log.debug("Registered resource " + resource);
  82                         }
  83
  84                         Map<String, String> defaultBranding = null;
  85                         if (branding.containsKey("*"))
  86                                 defaultBranding = branding.get("*");
  87
  88                         // entry points
  89                         for (String page : pages.keySet()) {
  90                                 Map<String, String> properties = defaultBranding != null ? new HashMap<String, String>(
  91                                                 defaultBranding) : new HashMap<String, String>();
  92                                 if (branding.containsKey(page)) {
  93                                         properties.putAll(branding.get(page));
  94                                 }
  95                                 // favicon
  96                                 if (properties.containsKey(WebClient.FAVICON)) {
  97                                         String faviconRelPath = properties.get(WebClient.FAVICON);
  98                                         application.addResource(faviconRelPath,
  99                                                         new BundleResourceLoader(bundleContext));
 100                                         if (log.isTraceEnabled())
 101                                                 log.trace("Registered favicon " + faviconRelPath);
 102
 103                                 }
 104
 105                                 // page title
 106                                 if (!properties.containsKey(WebClient.PAGE_TITLE)) {
 107                                         if (page.length() > 0)
 108                                                 properties.put(
 109                                                                 WebClient.PAGE_TITLE,
 110                                                                 Character.toUpperCase(page.charAt(0))
 111                                                                                 + page.substring(1));
 112                                 }
 113
 114                                 // default body HTML
 115                                 if (!properties.containsKey(WebClient.BODY_HTML))
 116                                         properties.put(WebClient.BODY_HTML, DEFAULT_LOADING_BODY);
 117
 118                                 //
 119                                 // ADD ENTRY POINT
 120                                 //
 121                                 application.addEntryPoint("/" + page, new CmsEntryPointFactory(
 122                                                 pages.get(page), repository, workspace, properties),
 123                                                 properties);
 124                                 log.info("Registered entry point /" + page);
 125                         }
 126
 127                         // stylesheets
 128                         for (String themeId : styleSheets.keySet()) {
 129                                 List<String> cssLst = styleSheets.get(themeId);
 130                                 for (String css : cssLst) {
 131                                         application.addStyleSheet(themeId, css, styleSheetRL);
 132                                 }
 133
 134                         }
 135                 } catch (RuntimeException e) {
 136                         // Easier access to initialisation errors
 137                         log.error("Unexpected exception when configuring RWT application.",
 138                                         e);
 139                         throw e;
 140                 }
 141         }
 142
 143         public void init() throws RepositoryException {
 144                 Session session = null;
 145                 try {
 146                         session = JcrUtils.loginOrCreateWorkspace(repository, workspace);
 147                         VersionManager vm = session.getWorkspace().getVersionManager();
 148                         if (!vm.isCheckedOut("/"))
 149                                 vm.checkout("/");
 150                         JcrUtils.mkdirs(session, basePath);
 151                         for (String principal : rwPrincipals)
 152                                 JcrUtils.addPrivilege(session, basePath, principal,
 153                                                 Privilege.JCR_WRITE);
 154                         for (String principal : roPrincipals)
 155                                 JcrUtils.addPrivilege(session, basePath, principal,
 156                                                 Privilege.JCR_READ);
 157
 158                         for (String pageName : pages.keySet()) {
 159                                 try {
 160                                         initPage(session, pages.get(pageName));
 161                                         session.save();
 162                                 } catch (Exception e) {
 163                                         throw new CmsException(
 164                                                         "Cannot initialize page " + pageName, e);
 165                                 }
 166                         }
 167
 168                 } finally {
 169                         JcrUtils.logoutQuietly(session);
 170                 }
 171         }
 172
 173         protected void initPage(Session adminSession, CmsUiProvider page)
 174                         throws RepositoryException {
 175                 if (page instanceof LifeCycleUiProvider)
 176                         ((LifeCycleUiProvider) page).init(adminSession);
 177         }
 178
 179         public void destroy() {
 180                 for (String pageName : pages.keySet()) {
 181                         try {
 182                                 CmsUiProvider page = pages.get(pageName);
 183                                 if (page instanceof LifeCycleUiProvider)
 184                                         ((LifeCycleUiProvider) page).destroy();
 185                         } catch (Exception e) {
 186                                 log.error("Cannot destroy page " + pageName, e);
 187                         }
 188                 }
 189         }
 190
 191         public void setRepository(Repository repository) {
 192                 this.repository = repository;
 193         }
 194
 195         public void setWorkspace(String workspace) {
 196                 this.workspace = workspace;
 197         }
 198
 199         public void setHeader(CmsUiProvider header) {
 200                 this.header = header;
 201         }
 202
 203         public void setPages(Map<String, CmsUiProvider> pages) {
 204                 this.pages = pages;
 205         }
 206
 207         public void setBasePath(String basePath) {
 208                 this.basePath = basePath;
 209         }
 210
 211         public void setRoPrincipals(List<String> roPrincipals) {
 212                 this.roPrincipals = roPrincipals;
 213         }
 214
 215         public void setRwPrincipals(List<String> rwPrincipals) {
 216                 this.rwPrincipals = rwPrincipals;
 217         }
 218
 219         public void setHeaderHeight(Integer headerHeight) {
 220                 this.headerHeight = headerHeight;
 221         }
 222
 223         public void setBranding(Map<String, Map<String, String>> branding) {
 224                 this.branding = branding;
 225         }
 226
 227         public void setStyleSheets(Map<String, List<String>> styleSheets) {
 228                 this.styleSheets = styleSheets;
 229         }
 230
 231         public void setBundleContext(BundleContext bundleContext) {
 232                 this.bundleContext = bundleContext;
 233         }
 234
 235         public void setResources(List<String> resources) {
 236                 this.resources = resources;
 237         }
 238
 239         class CmsExceptionHandler implements ExceptionHandler {
 240
 241                 @Override
 242                 public void handleException(Throwable throwable) {
 243                         CmsUtils.getCmsView().exception(throwable);
 244                 }
 245
 246         }
 247
 248         private class CmsEntryPointFactory implements EntryPointFactory {
 249                 private final CmsUiProvider page;
 250                 private final Repository repository;
 251                 private final String workspace;
 252                 private final Map<String, String> properties;
 253
 254                 public CmsEntryPointFactory(CmsUiProvider page, Repository repository,
 255                                 String workspace, Map<String, String> properties) {
 256                         this.page = page;
 257                         this.repository = repository;
 258                         this.workspace = workspace;
 259                         this.properties = properties;
 260                 }
 261
 262                 @Override
 263                 public EntryPoint create() {
 264                         SimpleErgonomics entryPoint = new SimpleErgonomics(repository,
 265                                         workspace, basePath, page, properties) {
 266
 267                                 @Override
 268                                 protected void initUi(Composite parent) {
 269                                         // TODO Auto-generated method stub
 270                                         super.initUi(parent);
 271                                 }
 272                         };
 273                         // entryPoint.setState("");
 274                         entryPoint.setHeader(header);
 275                         entryPoint.setHeaderHeight(headerHeight);
 276                         // CmsSession.current.set(entryPoint);
 277                         return entryPoint;
 278                 }
 279
 280         }
 281
 282         private static ResourceLoader createResourceLoader(final String resourceName) {
 283                 return new ResourceLoader() {
 284                         public InputStream getResourceAsStream(String resourceName)
 285                                         throws IOException {
 286                                 return getClass().getClassLoader().getResourceAsStream(
 287                                                 resourceName);
 288                         }
 289                 };
 290         }
 291
 292         // private static ResourceLoader createUrlResourceLoader(final URL url) {
 293         // return new ResourceLoader() {
 294         // public InputStream getResourceAsStream(String resourceName)
 295         // throws IOException {
 296         // return url.openStream();
 297         // }
 298         // };
 299         // }
 300
 301         /*
 302          * TEXTS
 303          */
 304         private static String DEFAULT_LOADING_BODY = "<div"
 305                         + " style=\"position: absolute; left: 50%; top: 50%; margin: -32px -32px; width: 64px; height:64px\">"
 306                         + "<img src=\"./rwt-resources/" + LOADING_IMAGE
 307                         + "\" width=\"32\" height=\"32\" style=\"margin: 16px 16px\"/>"
 308                         + "</div>";
 309 }