AbstractCmsEntryPoint.java

   1 package org.argeo.cms;
   2
   3 import java.security.PrivilegedAction;
   4 import java.util.HashMap;
   5 import java.util.Map;
   6
   7 import javax.jcr.Node;
   8 import javax.jcr.PathNotFoundException;
   9 import javax.jcr.Property;
  10 import javax.jcr.Repository;
  11 import javax.jcr.RepositoryException;
  12 import javax.jcr.Session;
  13 import javax.jcr.nodetype.NodeType;
  14 import javax.security.auth.Subject;
  15 import javax.security.auth.login.CredentialNotFoundException;
  16 import javax.security.auth.login.LoginContext;
  17 import javax.security.auth.login.LoginException;
  18 import javax.servlet.http.HttpServletRequest;
  19
  20 import org.apache.commons.logging.Log;
  21 import org.apache.commons.logging.LogFactory;
  22 import org.argeo.ArgeoException;
  23 import org.argeo.cms.auth.AuthConstants;
  24 import org.argeo.cms.auth.HttpRequestCallbackHandler;
  25 import org.argeo.eclipse.ui.specific.UiContext;
  26 import org.argeo.jcr.JcrUtils;
  27 import org.eclipse.rap.rwt.RWT;
  28 import org.eclipse.rap.rwt.application.AbstractEntryPoint;
  29 import org.eclipse.rap.rwt.client.WebClient;
  30 import org.eclipse.rap.rwt.client.service.BrowserNavigation;
  31 import org.eclipse.rap.rwt.client.service.BrowserNavigationEvent;
  32 import org.eclipse.rap.rwt.client.service.BrowserNavigationListener;
  33 import org.eclipse.rap.rwt.client.service.JavaScriptExecutor;
  34 import org.eclipse.swt.widgets.Composite;
  35 import org.eclipse.swt.widgets.Display;
  36 import org.eclipse.swt.widgets.Shell;
  37
  38 /** Manages history and navigation */
  39 public abstract class AbstractCmsEntryPoint extends AbstractEntryPoint
  40                 implements CmsView {
  41         private final Log log = LogFactory.getLog(AbstractCmsEntryPoint.class);
  42
  43         private final Subject subject;
  44         private LoginContext loginContext;
  45
  46         private final Repository repository;
  47         private final String workspace;
  48         private final String defaultPath;
  49         private final Map<String, String> factoryProperties;
  50
  51         // Current state
  52         private Session session;
  53         private Node node;
  54         private String nodePath;// useful when changing auth
  55         private String state;
  56         private String page;
  57         private Throwable exception;
  58
  59         // Client services
  60         private final JavaScriptExecutor jsExecutor;
  61         private final BrowserNavigation browserNavigation;
  62
  63         public AbstractCmsEntryPoint(Repository repository, String workspace,
  64                         String defaultPath, Map<String, String> factoryProperties) {
  65                 this.repository = repository;
  66                 this.workspace = workspace;
  67                 this.defaultPath = defaultPath;
  68                 this.factoryProperties = new HashMap<String, String>(factoryProperties);
  69                 subject = new Subject();
  70
  71                 // Initial login
  72                 try {
  73                         loginContext = new LoginContext(AuthConstants.LOGIN_CONTEXT_USER,
  74                                         subject, new HttpRequestCallbackHandler(
  75                                                         UiContext.getHttpRequest()));
  76                         loginContext.login();
  77                 } catch (CredentialNotFoundException e) {
  78                         try {
  79                                 loginContext = new LoginContext(
  80                                                 AuthConstants.LOGIN_CONTEXT_ANONYMOUS, subject);
  81                                 loginContext.login();
  82                         } catch (LoginException e1) {
  83                                 throw new ArgeoException("Cannot log as anonymous", e);
  84                         }
  85                 } catch (LoginException e) {
  86                         throw new ArgeoException("Cannot initialize subject", e);
  87                 }
  88                 authChange(loginContext);
  89
  90                 jsExecutor = RWT.getClient().getService(JavaScriptExecutor.class);
  91                 browserNavigation = RWT.getClient().getService(BrowserNavigation.class);
  92                 if (browserNavigation != null)
  93                         browserNavigation
  94                                         .addBrowserNavigationListener(new CmsNavigationListener());
  95         }
  96
  97         @Override
  98         protected Shell createShell(Display display) {
  99                 Shell shell = super.createShell(display);
 100                 shell.setData(RWT.CUSTOM_VARIANT, CmsStyles.CMS_SHELL);
 101                 display.disposeExec(new Runnable() {
 102
 103                         @Override
 104                         public void run() {
 105                                 if (log.isTraceEnabled())
 106                                         log.trace("Logging out " + session);
 107                                 JcrUtils.logoutQuietly(session);
 108                         }
 109                 });
 110                 return shell;
 111         }
 112
 113         @Override
 114         protected final void createContents(final Composite parent) {
 115                 UiContext.setData(CmsView.KEY, this);
 116                 Subject.doAs(subject, new PrivilegedAction<Void>() {
 117                         @Override
 118                         public Void run() {
 119                                 try {
 120                                         initUi(parent);
 121                                 } catch (Exception e) {
 122                                         throw new CmsException("Cannot create entrypoint contents",
 123                                                         e);
 124                                 }
 125                                 return null;
 126                         }
 127                 });
 128         }
 129
 130         /** Create UI */
 131         protected abstract void initUi(Composite parent);
 132
 133         /** Recreate UI after navigation or auth change */
 134         protected abstract void refresh();
 135
 136         /**
 137          * The node to return when no node was found (for authenticated users and
 138          * anonymous)
 139          */
 140         protected Node getDefaultNode(Session session) throws RepositoryException {
 141                 if (!session.hasPermission(defaultPath, "read")) {
 142                         if (session.getUserID().equals(AuthConstants.ROLE_ANONYMOUS))
 143                                 // TODO throw a special exception
 144                                 throw new CmsException("Login required");
 145                         else
 146                                 throw new CmsException("Unauthorized");
 147                 }
 148                 return session.getNode(defaultPath);
 149         }
 150
 151         protected String getBaseTitle() {
 152                 return factoryProperties.get(WebClient.PAGE_TITLE);
 153         }
 154
 155         public void navigateTo(String state) {
 156                 exception = null;
 157                 String title = setState(state);
 158                 doRefresh();
 159                 if (browserNavigation != null)
 160                         browserNavigation.pushState(state, title);
 161         }
 162
 163         @Override
 164         public synchronized Subject getSubject() {
 165                 return subject;
 166         }
 167
 168         @Override
 169         public synchronized void logout() {
 170                 if (loginContext == null)
 171                         throw new CmsException("Login context should not be null");
 172                 try {
 173                         loginContext.logout();
 174                         LoginContext anonymousLc = new LoginContext(
 175                                         AuthConstants.LOGIN_CONTEXT_ANONYMOUS, subject);
 176                         anonymousLc.login();
 177                         authChange(anonymousLc);
 178                 } catch (LoginException e) {
 179                         throw new CmsException("Cannot logout", e);
 180                 }
 181         }
 182
 183         @Override
 184         public synchronized void authChange(LoginContext loginContext) {
 185                 if (loginContext == null)
 186                         throw new CmsException("Login context cannot be null");
 187                 this.loginContext = loginContext;
 188                 Subject.doAs(loginContext.getSubject(), new PrivilegedAction<Void>() {
 189
 190                         @Override
 191                         public Void run() {
 192                                 try {
 193                                         JcrUtils.logoutQuietly(session);
 194                                         session = repository.login(workspace);
 195                                         if (nodePath != null)
 196                                                 try {
 197                                                         node = session.getNode(nodePath);
 198                                                 } catch (PathNotFoundException e) {
 199                                                         // logout();
 200                                                         // session = repository.login(workspace);
 201                                                         navigateTo("~");
 202                                                         throw e;
 203                                                 }
 204
 205                                         // refresh UI
 206                                         doRefresh();
 207                                 } catch (RepositoryException e) {
 208                                         throw new CmsException("Cannot perform auth change", e);
 209                                 }
 210                                 return null;
 211                         }
 212
 213                 });
 214
 215         }
 216
 217         @Override
 218         public void exception(final Throwable e) {
 219                 AbstractCmsEntryPoint.this.exception = e;
 220                 log.error("Unexpected exception in CMS", e);
 221                 doRefresh();
 222         }
 223
 224         protected synchronized void doRefresh() {
 225                 Subject.doAs(subject, new PrivilegedAction<Void>() {
 226                         @Override
 227                         public Void run() {
 228                                 refresh();
 229                                 return null;
 230                         }
 231                 });
 232         }
 233
 234         /** Sets the state of the entry point and retrieve the related JCR node. */
 235         protected synchronized String setState(String newState) {
 236                 String previousState = this.state;
 237
 238                 Node node = null;
 239                 page = null;
 240                 this.state = newState;
 241                 if (newState.equals("~"))
 242                         this.state = "";
 243
 244                 try {
 245                         int firstSlash = state.indexOf('/');
 246                         if (firstSlash == 0) {
 247                                 if (session.nodeExists(state))
 248                                         node = session.getNode(state);
 249                                 else
 250                                         throw new CmsException("Data " + state + " does not exist");
 251                                 page = "";
 252                         } else if (firstSlash > 0) {
 253                                 String prefix = state.substring(0, firstSlash);
 254                                 String path = state.substring(firstSlash);
 255                                 if (session.nodeExists(path))
 256                                         node = session.getNode(path);
 257                                 else
 258                                         throw new CmsException("Data " + path + " does not exist");
 259                                 page = prefix;
 260                         } else {
 261                                 node = getDefaultNode(session);
 262                                 page = state;
 263                         }
 264                         setNode(node);
 265                         String title = publishMetaData(node);
 266
 267                         if (log.isTraceEnabled())
 268                                 log.trace("node=" + node + ", state=" + state + " (page="
 269                                                 + page + ")");
 270
 271                         return title;
 272                 } catch (Exception e) {
 273                         log.error("Cannot set state '" + state + "'", e);
 274                         if (previousState.equals(""))
 275                                 previousState = "~";
 276                         navigateTo(previousState);
 277                         throw new CmsException("Unexpected issue when accessing #"
 278                                         + newState, e);
 279                 }
 280         }
 281
 282         private String publishMetaData(Node node) throws RepositoryException {
 283                 // Title
 284                 String title;
 285                 if (node.isNodeType(NodeType.MIX_TITLE)
 286                                 && node.hasProperty(Property.JCR_TITLE))
 287                         title = node.getProperty(Property.JCR_TITLE).getString() + " - "
 288                                         + getBaseTitle();
 289                 else
 290                         title = getBaseTitle();
 291
 292                 HttpServletRequest request = UiContext.getHttpRequest();
 293                 if (request == null)
 294                         return null;
 295                 // String url = CmsUtils.getCanonicalUrl(node, request);
 296                 // String desc = node.hasProperty(JCR_DESCRIPTION) ? node.getProperty(
 297                 // JCR_DESCRIPTION).getString() : null;
 298                 // String imgUrl = null;
 299                 // for (NodeIterator it = node.getNodes(); it.hasNext();) {
 300                 // Node child = it.nextNode();
 301                 // if (child.isNodeType(CmsTypes.CMS_IMAGE))
 302                 // imgUrl = CmsUtils.getDataUrl(child, request);
 303                 // }
 304
 305                 StringBuilder js = new StringBuilder();
 306                 js.append("document.title = '" + title + "';");
 307                 // js.append("var metas = document.getElementsByTagName('meta');");
 308                 // js.append("for (var i=0; i<metas.length; i++) {");
 309                 // js.append("  if (metas[i].getAttribute('property'))");
 310                 // js.append("   if(metas[i].getAttribute('property')=='og:title')");
 311                 // js.append("    metas[i].setAttribute('content','" + title + "');");
 312                 // js.append("   else if(metas[i].getAttribute('property')=='og:url')");
 313                 // js.append("    metas[i].setAttribute('content','" + url + "');");
 314                 // js.append("   else if(metas[i].getAttribute('property')=='og:type')");
 315                 // js.append("    metas[i].setAttribute('content','website');");
 316                 // if (desc != null) {
 317                 // js.append("   else if(metas[i].getAttribute('property')=='og:decription')");
 318                 // js.append("    metas[i].setAttribute('content','" + clean(desc)
 319                 // + "');");
 320                 // }
 321                 // if (imgUrl != null) {
 322                 // js.append("   else if(metas[i].getAttribute('property')=='og:image')");
 323                 // js.append("    metas[i].setAttribute('content','" + imgUrl + "');");
 324                 // } else {
 325                 // // TODO reset default image
 326                 // }
 327                 // js.append("  };");
 328                 jsExecutor.execute(js.toString());
 329                 return title;
 330         }
 331
 332         // Simply remove some illegal character
 333         // private String clean(String stringToClean) {
 334         // return stringToClean.replaceAll("'", "").replaceAll("\\n", "")
 335         // .replaceAll("\\t", "");
 336         // }
 337
 338         protected synchronized Node getNode() {
 339                 return node;
 340         }
 341
 342         private synchronized void setNode(Node node) throws RepositoryException {
 343                 this.node = node;
 344                 this.nodePath = node == null ? null : node.getPath();
 345         }
 346
 347         protected String getState() {
 348                 return state;
 349         }
 350
 351         protected Throwable getException() {
 352                 return exception;
 353         }
 354
 355         protected void resetException() {
 356                 exception = null;
 357         }
 358
 359         protected Session getSession() {
 360                 return session;
 361         }
 362
 363         private class CmsNavigationListener implements BrowserNavigationListener {
 364                 private static final long serialVersionUID = -3591018803430389270L;
 365
 366                 @Override
 367                 public void navigated(BrowserNavigationEvent event) {
 368                         setState(event.getState());
 369                         refresh();
 370                 }
 371         }
 372 }