org.argeo.cms/src/org/argeo/cms/CmsEntryPointFactory.java

   1 package org.argeo.cms;
   2
   3 import java.io.PrintWriter;
   4 import java.io.StringWriter;
   5 import java.util.Arrays;
   6 import java.util.LinkedHashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 import javax.jcr.Node;
  11 import javax.jcr.Repository;
  12 import javax.jcr.RepositoryException;
  13 import javax.jcr.Session;
  14 import javax.jcr.security.Privilege;
  15 import javax.jcr.version.VersionManager;
  16
  17 import org.apache.commons.io.IOUtils;
  18 import org.apache.commons.logging.Log;
  19 import org.apache.commons.logging.LogFactory;
  20 import org.argeo.cms.internal.ImageManagerImpl;
  21 import org.argeo.jcr.JcrUtils;
  22 import org.eclipse.rap.rwt.RWT;
  23 import org.eclipse.rap.rwt.application.EntryPoint;
  24 import org.eclipse.rap.rwt.application.EntryPointFactory;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.layout.FillLayout;
  27 import org.eclipse.swt.layout.GridData;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Control;
  30 import org.eclipse.swt.widgets.Label;
  31 import org.eclipse.swt.widgets.Text;
  32
  33 /** Creates and registers an {@link EntryPoint} */
  34 public class CmsEntryPointFactory implements EntryPointFactory {
  35         private final static Log log = LogFactory
  36                         .getLog(CmsEntryPointFactory.class);
  37
  38         private Repository repository;
  39         private String workspace = null;
  40         private String basePath = "/";
  41         private List<String> roPrincipals = Arrays.asList("anonymous", "everyone");
  42         private List<String> rwPrincipals = Arrays.asList("everyone");
  43
  44         private CmsLogin cmsLogin;
  45
  46         private CmsUiProvider header;
  47         // private CmsUiProvider dynamicPages;
  48         // private Map<String, CmsUiProvider> staticPages;
  49         private Map<String, CmsUiProvider> pages = new LinkedHashMap<String, CmsUiProvider>();
  50
  51         private Integer headerHeight = 40;
  52
  53         // Managers
  54         private CmsImageManager imageManager = new ImageManagerImpl();
  55
  56         @Override
  57         public EntryPoint create() {
  58                 CmsEntryPoint cmsEntryPoint = new CmsEntryPoint(repository, workspace);
  59                 CmsSession.current.set(cmsEntryPoint);
  60                 return cmsEntryPoint;
  61         }
  62
  63         public void init() throws RepositoryException {
  64                 if (workspace == null)
  65                         throw new CmsException(
  66                                         "Workspace must be set when calling initialization."
  67                                                         + " Please make sure that read-only and read-write roles"
  68                                                         + " have been properly configured:"
  69                                                         + " the defaults are open.");
  70
  71                 Session session = null;
  72                 try {
  73                         session = JcrUtils.loginOrCreateWorkspace(repository, workspace);
  74                         VersionManager vm = session.getWorkspace().getVersionManager();
  75                         if (!vm.isCheckedOut("/"))
  76                                 vm.checkout("/");
  77                         // session = repository.login(workspace);
  78                         JcrUtils.mkdirs(session, basePath);
  79                         for (String principal : rwPrincipals)
  80                                 JcrUtils.addPrivilege(session, basePath, principal,
  81                                                 Privilege.JCR_WRITE);
  82                         for (String principal : roPrincipals)
  83                                 JcrUtils.addPrivilege(session, basePath, principal,
  84                                                 Privilege.JCR_READ);
  85
  86                         for (String pageName : pages.keySet()) {
  87                                 try {
  88                                         initPage(session, pages.get(pageName));
  89                                         session.save();
  90                                 } catch (Exception e) {
  91                                         throw new CmsException(
  92                                                         "Cannot initialize page " + pageName, e);
  93                                 }
  94                         }
  95
  96                 } finally {
  97                         JcrUtils.logoutQuietly(session);
  98                 }
  99         }
 100
 101         protected void initPage(Session adminSession, CmsUiProvider page)
 102                         throws RepositoryException {
 103                 if (page instanceof LifeCycleUiProvider)
 104                         ((LifeCycleUiProvider) page).init(adminSession);
 105         }
 106
 107         public void destroy() {
 108                 for (String pageName : pages.keySet()) {
 109                         try {
 110                                 CmsUiProvider page = pages.get(pageName);
 111                                 if (page instanceof LifeCycleUiProvider)
 112                                         ((LifeCycleUiProvider) page).destroy();
 113                         } catch (Exception e) {
 114                                 log.error("Cannot destroy page " + pageName, e);
 115                         }
 116                 }
 117         }
 118
 119         public void setRepository(Repository repository) {
 120                 this.repository = repository;
 121         }
 122
 123         public void setWorkspace(String workspace) {
 124                 this.workspace = workspace;
 125         }
 126
 127         public void setCmsLogin(CmsLogin cmsLogin) {
 128                 this.cmsLogin = cmsLogin;
 129         }
 130
 131         public void setHeader(CmsUiProvider header) {
 132                 this.header = header;
 133         }
 134
 135         public void setPages(Map<String, CmsUiProvider> pages) {
 136                 this.pages = pages;
 137         }
 138
 139         @Deprecated
 140         public void setDynamicPages(CmsUiProvider dynamicPages) {
 141                 log.warn("'dynamicPages' is deprecated, use 'pages' instead, with \"\" as key");
 142                 pages.put("", dynamicPages);
 143         }
 144
 145         @Deprecated
 146         public void setStaticPages(Map<String, CmsUiProvider> staticPages) {
 147                 log.warn("'staticPages' is deprecated, use 'pages' instead");
 148                 pages.putAll(staticPages);
 149         }
 150
 151         public void setBasePath(String basePath) {
 152                 this.basePath = basePath;
 153         }
 154
 155         public void setRoPrincipals(List<String> roPrincipals) {
 156                 this.roPrincipals = roPrincipals;
 157         }
 158
 159         public void setRwPrincipals(List<String> rwPrincipals) {
 160                 this.rwPrincipals = rwPrincipals;
 161         }
 162
 163         public void setHeaderHeight(Integer headerHeight) {
 164                 this.headerHeight = headerHeight;
 165         }
 166
 167         private class CmsEntryPoint extends AbstractCmsEntryPoint {
 168                 private Composite headerArea;
 169                 private Composite bodyArea;
 170
 171                 public CmsEntryPoint(Repository repository, String workspace) {
 172                         super(repository, workspace);
 173                 }
 174
 175                 @Override
 176                 protected void createContents(Composite parent) {
 177                         try {
 178                                 getShell().getDisplay().setData(CmsSession.KEY, this);
 179
 180                                 parent.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
 181                                                 true));
 182                                 parent.setLayout(CmsUtils.noSpaceGridLayout());
 183
 184                                 headerArea = new Composite(parent, SWT.NONE);
 185                                 headerArea.setLayout(new FillLayout());
 186                                 GridData headerData = new GridData(SWT.FILL, SWT.FILL, false,
 187                                                 false);
 188                                 headerData.heightHint = headerHeight;
 189                                 headerArea.setLayoutData(headerData);
 190                                 refreshHeader();
 191
 192                                 bodyArea = new Composite(parent, SWT.NONE);
 193                                 bodyArea.setData(RWT.CUSTOM_VARIANT, CmsStyles.CMS_BODY);
 194                                 bodyArea.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
 195                                                 true));
 196                                 bodyArea.setBackgroundMode(SWT.INHERIT_DEFAULT);
 197                                 bodyArea.setLayout(CmsUtils.noSpaceGridLayout());
 198                         } catch (Exception e) {
 199                                 throw new CmsException("Cannot create entrypoint contents", e);
 200                         }
 201                 }
 202
 203                 @Override
 204                 protected void refreshHeader() {
 205                         if (headerArea == null)
 206                                 return;
 207                         for (Control child : headerArea.getChildren())
 208                                 child.dispose();
 209                         try {
 210                                 header.createUi(headerArea, getNode());
 211                         } catch (RepositoryException e) {
 212                                 throw new CmsException("Cannot refresh header", e);
 213                         }
 214                         headerArea.layout(true, true);
 215                 }
 216
 217                 @Override
 218                 protected void refreshBody() {
 219                         if (bodyArea == null)
 220                                 return;
 221                         // clear
 222                         for (Control child : bodyArea.getChildren())
 223                                 child.dispose();
 224                         bodyArea.setLayout(CmsUtils.noSpaceGridLayout());
 225
 226                         // Exception
 227                         Throwable exception = getException();
 228                         if (exception != null) {
 229                                 new Label(bodyArea, SWT.NONE).setText("Unreachable state : "
 230                                                 + getState());
 231                                 if (getNode() != null)
 232                                         new Label(bodyArea, SWT.NONE).setText("Context : "
 233                                                         + getNode());
 234
 235                                 Text errorText = new Text(bodyArea, SWT.MULTI | SWT.H_SCROLL
 236                                                 | SWT.V_SCROLL);
 237                                 errorText.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,
 238                                                 true));
 239                                 StringWriter sw = new StringWriter();
 240                                 exception.printStackTrace(new PrintWriter(sw));
 241                                 errorText.setText(sw.toString());
 242                                 IOUtils.closeQuietly(sw);
 243                                 resetException();
 244                                 // TODO report
 245                         } else {
 246                                 String state = getState();
 247                                 String page = getPage();
 248                                 try {
 249                                         if (state == null)
 250                                                 throw new CmsException("State cannot be null");
 251                                         if (page == null)
 252                                                 throw new CmsException("Page cannot be null");
 253                                         // else if (state.length() == 0)
 254                                         // log.debug("empty state");
 255                                         else if (pages.containsKey(page))
 256                                                 pages.get(page).createUi(bodyArea, getNode());
 257                                         else {
 258                                                 // try {
 259                                                 // RWT.getResponse().sendError(404);
 260                                                 // } catch (IOException e) {
 261                                                 // log.error("Cannot send 404 code", e);
 262                                                 // }
 263                                                 throw new CmsException("Unsupported state " + state);
 264                                         }
 265                                 } catch (RepositoryException e) {
 266                                         throw new CmsException("Cannot refresh body", e);
 267                                 }
 268                         }
 269                         bodyArea.layout(true, true);
 270                 }
 271
 272                 @Override
 273                 protected void logAsAnonymous() {
 274                         cmsLogin.logInAsAnonymous();
 275                 }
 276
 277                 @Override
 278                 protected Node getDefaultNode(Session session)
 279                                 throws RepositoryException {
 280                         if (!session.hasPermission(basePath, "read")) {
 281                                 if (session.getUserID().equals("anonymous"))
 282                                         throw new CmsLoginRequiredException();
 283                                 else
 284                                         throw new CmsException("Unauthorized");
 285                         }
 286                         return session.getNode(basePath);
 287                 }
 288
 289                 @Override
 290                 public CmsImageManager getImageManager() {
 291                         return imageManager;
 292                 }
 293
 294         }
 295 }