/ - Diff - EDIT - EDIT Project Management

     package eu.etaxonomy.cdm.vaadin.presenter;
     import java.net.URI;
     import org.springframework.security.authentication.AuthenticationManager;
     import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     import org.springframework.security.core.Authentication;
     import com.vaadin.server.VaadinSession;
     import eu.etaxonomy.cdm.vaadin.util.CdmSpringContextHelper;
     import eu.etaxonomy.cdm.vaadin.view.AuthenticationView;
     import eu.etaxonomy.cdm.vaadin.util.CdmVaadinAuthentication;
     import eu.etaxonomy.cdm.vaadin.util.CdmVaadinSessionUtilities;
     import eu.etaxonomy.cdm.vaadin.view.IAuthenticationComponent;
     public class AuthenticationPresenter implements IAuthenticationComponent.AuthenticationComponentListener{
     	private final AuthenticationView view;
     	public AuthenticationPresenter(AuthenticationView view) {
     		this.view = view;
     		view.addListener(this);
+    	}
     	@Override
     	public Authentication login(String userName, String password) {
     		UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(userName, password);
     		AuthenticationManager authenticationManager = (AuthenticationManager) CdmSpringContextHelper.getCurrent().getBean("authenticationManager");
     		Authentication authentication = authenticationManager.authenticate(token);
     		return authentication;
+    	}
         @Override
         public boolean login(URI uri, String context, String userName, String password) {
             UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(userName, password);
             AuthenticationManager authenticationManager = (AuthenticationManager) CdmSpringContextHelper.getCurrent().getBean("authenticationManager");
             Authentication authentication = authenticationManager.authenticate(token);
             if(authentication != null && authentication.isAuthenticated()) {
                 CdmVaadinAuthentication cvAuthentication = (CdmVaadinAuthentication) VaadinSession.getCurrent().getAttribute(CdmVaadinAuthentication.KEY);
                 if(cvAuthentication == null) {
                     cvAuthentication = new CdmVaadinAuthentication();
+                }
                 cvAuthentication.addAuthentication(uri, context, authentication);
                 CdmVaadinSessionUtilities.setCurrentAttribute(CdmVaadinAuthentication.KEY, cvAuthentication);
                 return true;
+            }
             return false;
+        }
+    }

     package eu.etaxonomy.cdm.vaadin.ui;
     import java.net.URI;
     import java.util.logging.Logger;
     import org.springframework.security.core.Authentication;
     import com.vaadin.navigator.Navigator;
     import com.vaadin.server.Page;
     import com.vaadin.server.VaadinRequest;
     import com.vaadin.server.VaadinServlet;
     import com.vaadin.server.VaadinSession;
     import com.vaadin.ui.UI;
     import eu.etaxonomy.cdm.vaadin.presenter.AuthenticationPresenter;
     import eu.etaxonomy.cdm.vaadin.util.CdmVaadinAuthentication;
     import eu.etaxonomy.cdm.vaadin.view.AuthenticationView;
     public abstract class AbstractAuthenticatedUI extends CdmBaseUI {
-...
             navigator.addView(AUTHENTICATION_VIEW, av);
             new AuthenticationPresenter(av);
             // Create and register the views
             Authentication authentication = (Authentication) VaadinSession.getCurrent().getAttribute("authentication");
             CdmVaadinAuthentication cvAuthentication = (CdmVaadinAuthentication) VaadinSession.getCurrent().getAttribute(CdmVaadinAuthentication.KEY);
             doInit(request);
             if(ignoreAuthentication || (authentication != null && authentication.isAuthenticated())) {
             	UI.getCurrent().getNavigator().navigateTo(getFirstViewName());
             URI uri = Page.getCurrent().getLocation();
             String context = VaadinServlet.getCurrent().getServletContext().getContextPath();
             if(ignoreAuthentication || (cvAuthentication != null && cvAuthentication.isAuthenticated(uri, context))) {
                 UI.getCurrent().getNavigator().navigateTo(getFirstViewName());
             } else {
             	UI.getCurrent().getNavigator().navigateTo(AUTHENTICATION_VIEW);
                 UI.getCurrent().getNavigator().navigateTo(AUTHENTICATION_VIEW);
+            }
+    	}

     // $Id$
     /**
      * Copyright (C) 2015 EDIT
      * European Distributed Institute of Taxonomy
      * http://www.e-taxonomy.eu
+     *
      * The contents of this file are subject to the Mozilla Public License Version 1.1
      * See LICENSE.TXT at the top of this package for the full license terms.
      */
     package eu.etaxonomy.cdm.vaadin.util;
     import java.net.URI;
     import java.util.HashMap;
     import java.util.Map;
     import org.apache.log4j.Logger;
     import org.springframework.security.core.Authentication;
     /**
      * @author cmathew
      * @date 28 Apr 2015
+     *
      */
     public class CdmVaadinAuthentication {
         private final static Logger logger = Logger.getLogger(CdmVaadinAuthentication.class);
         public static final String KEY = "key_authentication";
         Map<String, Authentication> hostAuthenticationMap = new HashMap<String, Authentication>();
         public void addAuthentication(URI requestSourceUri, String requestSourceContext, Authentication authentication) {
             addAuthentication(getRequestSource(requestSourceUri, requestSourceContext), authentication);
+        }
         public void addAuthentication(String requestSource, Authentication authentication) {
             if(requestSource == null || requestSource.isEmpty()) {
                 throw new IllegalStateException("When setting authentication, host cannot be null or empty");
+            }
             if(authentication == null) {
                 throw new IllegalStateException("When setting authentication, authentication object cannot be null");
+            }
             hostAuthenticationMap.put(requestSource, authentication);
+        }
         public boolean isAuthenticated(URI uri, String context) {
             if(uri != null && context != null && !context.isEmpty()) {
                 Authentication authentication = hostAuthenticationMap.get(getRequestSource(uri, context));
                 if(authentication != null) {
                     return authentication.isAuthenticated();
+                }
+            }
             return false;
+        }
         public static String getRequestSource(URI uri, String context) {
             String source = uri.getHost() + ":" + String.valueOf(uri.getPort()) + context;
             logger.warn(" request source : " + source);
             return source;
+        }
+    }

     */
     package eu.etaxonomy.cdm.vaadin.util;
     import java.util.concurrent.locks.Lock;
     import org.apache.log4j.Logger;
     import com.vaadin.server.VaadinSession;
-...
         private static final Logger logger = Logger.getLogger(CdmVaadinSessionUtilities.class);
         public static void setCurrentAttribute(String name, Object value) {
             Lock sessionLock = VaadinSession.getCurrent().getLockInstance();
             try {
                 VaadinSession.getCurrent().getLockInstance().lock();
                 if(sessionLock != null) {
                     sessionLock.lock();
+                }
                 VaadinSession.getCurrent().setAttribute(name, value);
             } finally {
                 VaadinSession.getCurrent().getLockInstance().unlock();
                 if(sessionLock != null) {
                     sessionLock.unlock();
+                }
+            }
+        }

     package eu.etaxonomy.cdm.vaadin.view;
     import org.springframework.security.authentication.BadCredentialsException;
     import org.springframework.security.core.Authentication;
     import com.vaadin.annotations.AutoGenerated;
     import com.vaadin.data.validator.StringLengthValidator;
     import com.vaadin.event.ShortcutAction.KeyCode;
     import com.vaadin.navigator.View;
     import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
     import com.vaadin.server.Page;
     import com.vaadin.server.VaadinServlet;
     import com.vaadin.ui.Alignment;
     import com.vaadin.ui.Button;
     import com.vaadin.ui.Button.ClickEvent;
-...
     import com.vaadin.ui.UI;
     import com.vaadin.ui.VerticalLayout;
     import eu.etaxonomy.cdm.vaadin.presenter.AuthenticationPresenter;
     import eu.etaxonomy.cdm.vaadin.ui.AbstractAuthenticatedUI;
     import eu.etaxonomy.cdm.vaadin.util.CdmVaadinSessionUtilities;
     public class AuthenticationView extends CustomComponent implements IAuthenticationComponent, ClickListener , View {
-...
     		userNameTF.setNullRepresentation("");
     		userNameTF.focus();
     		authListener = new AuthenticationPresenter();
     		loginBtn.addClickListener(this);
     		loginBtn.setClickShortcut(KeyCode.ENTER, null);
+    	}
-...
     	@Override
     	public void buttonClick(ClickEvent event) {
     		Authentication authentication = null;
     		try {
     			authentication = authListener.login(userNameTF.getValue(), passwordField.getValue());
     		} catch(BadCredentialsException e){
     			Notification.show("Bad credentials", Notification.Type.ERROR_MESSAGE);
+    		}
     		if(authentication != null && authentication.isAuthenticated()) {
     			CdmVaadinSessionUtilities.setCurrentAttribute("authentication", authentication);
     			// we are sure that since we are in the authentication view that the
     			// current ui should be of type AbstractAuthenticatedUI
     			AbstractAuthenticatedUI aaui = (AbstractAuthenticatedUI) UI.getCurrent();
     			UI.getCurrent().getNavigator().navigateTo(aaui.getFirstViewName());
+    		}
     	    boolean isAuthenticated = false;
     	    try {
     	        isAuthenticated = authListener.login(Page.getCurrent().getLocation(),
     	                VaadinServlet.getCurrent().getServletContext().getContextPath(),
     	                userNameTF.getValue(),
     	                passwordField.getValue());
     	        if(isAuthenticated) {
     	            // we are sure that since we are in the authentication view that the
     	            // current ui should be of type AbstractAuthenticatedUI
     	            AbstractAuthenticatedUI aaui = (AbstractAuthenticatedUI) UI.getCurrent();
     	            UI.getCurrent().getNavigator().navigateTo(aaui.getFirstViewName());
+    	        }
     	    } catch(BadCredentialsException e){
     	        Notification.show("Bad credentials", Notification.Type.ERROR_MESSAGE);
+    	    }
+    	}
     	@Override

     package eu.etaxonomy.cdm.vaadin.view;
     import org.springframework.security.core.Authentication;
     import java.net.URI;
     public interface IAuthenticationComponent {
     	public interface AuthenticationComponentListener {
             Authentication login(String userName, String password);
             /**
              * @param uri
              * @param context
              * @param userName
              * @param password
              * @return
              */
             boolean login(URI uri, String context, String userName, String password);
+        }
         public void addListener(AuthenticationComponentListener listener);
+    }

+        	}
         	QueryBuilder.setStringDecorator(new CdmSQLStringDecorator());
         	Assert.assertNotNull(vaadinServlet);
         	Assert.assertEquals(vaadinServlet, VaadinServlet.getCurrent());
         	Assert.assertNotNull(servletContext);
             Assert.assertEquals(servletContext, VaadinServlet.getCurrent().getServletContext());
             Assert.assertNotNull(vaadinSession);
             Assert.assertEquals(vaadinSession, VaadinSession.getCurrent());
             Assert.assertNotNull(vaadinService);
             Assert.assertEquals(vaadinService, VaadinService.getCurrent());
+        }
-...
+    		}
     		VaadinService.setCurrent(vaadinService);
     		vaadinSession = new VaadinSession(vaadinService);
     		vaadinSession = new MockVaadinSession(vaadinService);
     		VaadinSession.setCurrent(vaadinSession);
     		isVaadinServletEnvCreated = true;
+        }
         public static  class MockVaadinSession extends VaadinSession {
             MockVaadinSession(VaadinService service) {
                 super(service);
+            }
             @Override
             public boolean hasLock() {
                 return true;
+            }
+        }
+    }

     // $Id$
     /**
     * Copyright (C) 2015 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.vaadin.presenter;
     import java.net.URI;
     import java.net.URISyntaxException;
     import org.apache.log4j.Logger;
     import org.junit.Assert;
     import org.junit.BeforeClass;
     import org.junit.Test;
     import org.springframework.security.authentication.BadCredentialsException;
     import com.vaadin.server.VaadinSession;
     import eu.etaxonomy.cdm.vaadin.CdmVaadinBaseTest;
     import eu.etaxonomy.cdm.vaadin.util.CdmVaadinAuthentication;
     /**
      * @author cmathew
      * @date 28 Apr 2015
+     *
      */
     public class AuthenticationPresenterTest extends CdmVaadinBaseTest {
         private static final Logger logger = Logger.getLogger(AuthenticationPresenterTest.class);
         private static AuthenticationPresenter ap;
         @BeforeClass
         public static void init() {
             ap = new AuthenticationPresenter();
+        }
         @Test
         public void testLogin() throws URISyntaxException {
             URI uri = new URI("http://localhost:8080/cdm-vaadin/app/authtest");
             String context = "/cdm-vaadin";
             boolean isAuthenticated = false;
             try {
                 isAuthenticated = ap.login(uri, context, "admin", "000");
                 Assert.fail("BadCredentialsException should be thrown here");
             } catch(BadCredentialsException e){
+            }
             isAuthenticated = ap.login(uri, context, "admin", "00000");
             Assert.assertTrue(isAuthenticated);
             CdmVaadinAuthentication authentication = (CdmVaadinAuthentication) VaadinSession.getCurrent().getAttribute(CdmVaadinAuthentication.KEY);
             Assert.assertTrue(authentication.isAuthenticated(uri, context));
             URI anotherUri = new URI("http://localhost:8081/cdm-edit/app/authtest");
             Assert.assertFalse(authentication.isAuthenticated(anotherUri, context));
             String anotherContext = "/cdm-edit";
             Assert.assertFalse(authentication.isAuthenticated(uri, anotherContext));
             isAuthenticated = ap.login(anotherUri, anotherContext, "admin", "00000");
             Assert.assertTrue(isAuthenticated);
             Assert.assertTrue(authentication.isAuthenticated(anotherUri, anotherContext));
+        }
+    }

Project

General

Profile

EDIT

Revision 93fcde18

Added by Cherian Mathew almost 9 years ago