D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/dnet-modular-ui/trunk/", "deploy_repository": "dnet4-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet4-snapshots", "name": "dnet-modular-ui"}

package eu.dnetlib.functionality.modular.ui.users;

import static org.junit.Assert.*;

import org.junit.Before;

import org.junit.Test;

import org.springframework.core.io.ClassPathResource;

public class SimpleSSOAuthorizationManagerTest {

	private final static String PAYLOAD = "{\"uid\":\"michele.artini\",\"fullname\":\"Michele Artini\",\"email\":\"michele.artini@isti.cnr.it\"}";

	private final static String SIGNATURE = "89f7a05d39d7a1e6489506c0a27f6087cf4ca0c7f0298c29d61464f5522be146363e8ad63312cc3d7fdcf5b5f1ff7b26e64ed1009b52b6562deebbd267dc6f49e25714f54a8cd2936db6b15e27e9dfc7ab762728d33449e8734101265bbb8b70e5efe2845d5ae2da6e43f25ab75e531fa6cc15e31497bb344b1cca6d687ecf2501c407316423c3eecbe98df43a0721b63f3a1a07fc1e7d75855cc6dc9dce18817b008d60fb4b225d462755d5671fdd01d3c7b08d5d039524e45a78a808377a3cc44b13c0c8e314aa1893e88cd32120e8beeacf5df8412c8228c1e8aa046a159ea1d6a36de160456f32001e23978b1b2d15490a07943d95a56d9dfd0f7bc6b4c6";

	private SimpleSSOAuthorizationManager manager = new SimpleSSOAuthorizationManager();

	@Before

	public void setup() throws Exception {

		manager.setPubKeyAlgo("RSA");

		manager.setPubKeyFile(new ClassPathResource("/eu/dnetlib/functionality/modular/ui/users/pubkey.der"));

		manager.setSignatureAlgo("SHA1withRSA");

		manager.init();

	}

	@Test

	public void testIsValidMessage() {

		assertTrue(manager.isValidMessage(PAYLOAD, SIGNATURE));

		assertFalse(manager.isValidMessage(PAYLOAD.toLowerCase(), SIGNATURE));

		assertFalse(manager.isValidMessage(PAYLOAD + "123", SIGNATURE));

		assertFalse(manager.isValidMessage(PAYLOAD, SIGNATURE + "123"));

		assertFalse(manager.isValidMessage(PAYLOAD + PAYLOAD, SIGNATURE));

		assertFalse(manager.isValidMessage("aaa", "aaa"));

		assertFalse(manager.isValidMessage(null, SIGNATURE));

		assertFalse(manager.isValidMessage(PAYLOAD, null));

		assertFalse(manager.isValidMessage("", SIGNATURE));

		assertFalse(manager.isValidMessage(PAYLOAD, ""));

		assertFalse(manager.isValidMessage(null, ""));

		assertFalse(manager.isValidMessage("", null));

		assertFalse(manager.isValidMessage("", ""));

		assertFalse(manager.isValidMessage(null, null));

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.IOException;

import java.lang.management.ManagementFactory;

import java.lang.management.RuntimeMXBean;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.maven.model.Model;

import org.apache.maven.model.Parent;

import org.apache.maven.model.io.xpp3.MavenXpp3Reader;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.context.ResourceLoaderAware;

import org.springframework.core.io.Resource;

import org.springframework.core.io.ResourceLoader;

import org.springframework.core.io.support.ResourcePatternUtils;

import org.springframework.ui.ModelMap;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.miscutils.datetime.HumanTime;

public class InfoController extends ModuleEntryPoint implements ResourceLoaderAware {

	private String hostname;

	private String port;

	private String context;

	private ResourceLoader resourceLoader;

	private static final Log log = LogFactory.getLog(InfoController.class);

	@Override

	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) throws Exception {

		final RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();

		final Map<String, Map<String, String>> info = Maps.newLinkedHashMap();

		info.put("General", getGeneralInfo(mxbean));

		info.put("JVM", getJvmInfo(mxbean));

		info.put("Libraries and arguments", getLibInfo(mxbean));

		info.put("System properties", getSysInfo(mxbean));

		map.addAttribute("info", info);

		map.addAttribute("modules", getModules());

	}

	@SuppressWarnings("unchecked")

	private List<Map<String, Object>> getModules() throws IOException {

		final Map<String, Map<String, Map<String, Object>>> modules = Maps.newLinkedHashMap();

		final MavenXpp3Reader reader = new MavenXpp3Reader();

		for (Resource res : ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath*:/META-INF/**/pom.xml")) {

			try {

				final Model model = reader.read(res.getInputStream());

				final String name = model.getArtifactId();

				String groupId = model.getGroupId();

				for (Parent parent = model.getParent(); groupId == null && model.getParent() != null; parent = model.getParent()) {

					groupId = parent.getGroupId();

				}

				String version = model.getVersion();

				for (Parent parent = model.getParent(); version == null && model.getParent() != null; parent = model.getParent()) {

					version = parent.getVersion();

				}

				if (!modules.containsKey(groupId)) {

					modules.put(groupId, new HashMap<String, Map<String, Object>>());

				}

				if (!modules.get(groupId).containsKey(name)) {

					final Map<String, Object> map = Maps.newHashMap();

					map.put("group", groupId);

					map.put("name", name);

					map.put("files", new ArrayList<String>());

					map.put("versions", new ArrayList<String>());

					modules.get(groupId).put(name, map);

				} else {

					// Artifact already found

					modules.get(groupId).get(name).put("warning", "1");

				}

				((List<String>) modules.get(groupId).get(name).get("versions")).add(version);

				((List<String>) modules.get(groupId).get(name).get("files")).add(res.getURI().toString());

			} catch (Exception e) {

				log.error("Error evaluating pom: " + res.getURI());

				log.debug("-- ERROR --", e);

			}

		}

		final List<Map<String, Object>> list = Lists.newArrayList();

		for (Entry<String, Map<String, Map<String, Object>>> e : modules.entrySet()) {

			for (Entry<String, Map<String, Object>> e1 : e.getValue().entrySet()) {

				list.add(e1.getValue());

			}

		}

		Collections.sort(list, new Comparator<Map<String, Object>>() {

			@Override

			public int compare(final Map<String, Object> o1, final Map<String, Object> o2) {

				if (o1.get("group").equals(o2.get("group"))) {

					return o1.get("name").toString().compareTo(o2.get("name").toString());

				} else {

					return o1.get("group").toString().compareTo(o2.get("group").toString());

				}

			}

		});

		return list;

	}

	private Map<String, String> getSysInfo(final RuntimeMXBean mxbean) {

		return mxbean.getSystemProperties();

	}

	private Map<String, String> getGeneralInfo(final RuntimeMXBean mxbean) {

		final Map<String, String> genInfo = Maps.newLinkedHashMap();

		genInfo.put("Hostname", hostname);

		genInfo.put("Port", port);

		genInfo.put("Context", context);

		genInfo.put("Uptime", HumanTime.exactly(mxbean.getUptime()));

		genInfo.put("Start Time", DateUtils.calculate_ISO8601(mxbean.getStartTime()));

		return genInfo;

	}

	private Map<String, String> getJvmInfo(final RuntimeMXBean mxbean) {

		final Map<String, String> jvmInfo = Maps.newLinkedHashMap();

		jvmInfo.put("JVM Name", mxbean.getVmName());

		jvmInfo.put("JVM Vendor", mxbean.getVmVendor());

		jvmInfo.put("JVM Version", mxbean.getVmVersion());

		jvmInfo.put("JVM Spec Name", mxbean.getSpecName());

		jvmInfo.put("JVM Spec Vendor", mxbean.getSpecVendor());

		jvmInfo.put("JVM Spec Version", mxbean.getSpecVersion());

		jvmInfo.put("Running JVM Name", mxbean.getName());

		jvmInfo.put("Management Spec Version", mxbean.getManagementSpecVersion());

		return jvmInfo;

	}

	private Map<String, String> getLibInfo(final RuntimeMXBean mxbean) {

		final Map<String, String> libInfo = Maps.newLinkedHashMap();

		libInfo.put("Classpath", mxbean.getClassPath().replaceAll(":", " : "));

		libInfo.put("Boot ClassPath", mxbean.getBootClassPath().replaceAll(":", " : "));

		libInfo.put("Input arguments", mxbean.getInputArguments().toString());

		libInfo.put("Library Path", mxbean.getLibraryPath().replaceAll(":", " : "));

		return libInfo;

	}

	public String getHostname() {

		return hostname;

	}

	@Required

	public void setHostname(final String hostname) {

		this.hostname = hostname;

	}

	public String getPort() {

		return port;

	}

	@Required

	public void setPort(final String port) {

		this.port = port;

	}

	public String getContext() {

		return context;

	}

	@Required

	public void setContext(final String context) {

		this.context = context;

	}

	@Override

	public void setResourceLoader(final ResourceLoader resourceLoader) {

		this.resourceLoader = resourceLoader;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import com.google.common.collect.Lists;

import com.google.common.collect.Sets;

import eu.dnetlib.functionality.modular.ui.users.AccessLimited;

import eu.dnetlib.functionality.modular.ui.users.PermissionLevel;

import eu.dnetlib.functionality.modular.ui.users.User;

public class EntryPointsAggregator {

	@Autowired(required=false)

	private List<ModuleEntryPoint> entryPoints = Lists.newArrayList();;

	@Autowired(required=false)

	private List<AbstractMenu> otherMenus = Lists.newArrayList();

	public List<ModuleEntryPoint> getEntryPoints() {

		return entryPoints;

	}

	public void setEntryPoints(List<ModuleEntryPoint> entryPoints) {

		this.entryPoints = entryPoints;

	}

	public List<AbstractMenu> getMenus(User user) {

		final Map<String, ModulesMenu> map = new HashMap<String, ModulesMenu>();

		for (ModuleEntryPoint entry : entryPoints) {

			if (entry.isValidMenuEntry() && verifyAuthorization(entry, user)) {

				final String group = entry.getGroup();

				if (!map.containsKey(group)) {

					map.put(group, new ModulesMenu(group));

				}

				map.get(group).addEntry(entry);

			}

		}

		final List<AbstractMenu> items = Lists.newArrayList();

		for (AbstractMenu menu : otherMenus) {

			if (menu instanceof AccessLimited) {

				 if (verifyAuthorization((AccessLimited) menu, user) && menu.getEntries().size() > 0) {

					 items.add(menu);

				 }

			} else if (menu.getEntries().size() > 0) {

				items.add(menu);

			}

		}

		for (ModulesMenu item : map.values()) {

			item.complete();

			items.add(item);

		}

		Collections.sort(items);

		return items;

	}

	private boolean verifyAuthorization(AccessLimited entry, User user) {

		if (user.getPermissionLevels().contains(PermissionLevel.SUPER_ADMIN)) return true;

		return (Sets.intersection(user.getPermissionLevels(), entry.getPermissionLevels()).size() > 0);

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.IOException;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.functionality.modular.ui.users.AuthorizationDAO;

import eu.dnetlib.functionality.modular.ui.users.PermissionLevel;

import eu.dnetlib.functionality.modular.ui.users.User;

@Controller

public class UsersInternalController {

	@Resource(name="modularUiAuthorizationDao")

	private AuthorizationDAO dao;

	private static final Log log = LogFactory.getLog(UsersInternalController.class);

	@RequestMapping(value = "/ui/users.get")

	public @ResponseBody List<User> listUsers(HttpServletResponse response) throws IOException {

		final List<User> list = Lists.newArrayList();

		for (Map.Entry<String, Set<PermissionLevel>> e : dao.getPermissionLevels().entrySet()) {

			final User user = new User(e.getKey());

			user.setPermissionLevels(e.getValue());

			list.add(user);

		}

		Collections.sort(list);

		return list;

	}

	@RequestMapping(value = "/ui/saveusers.do", method=RequestMethod.POST)

	public @ResponseBody boolean updateUsers(@RequestBody final List<User> users) {

		log.info("Saving " + users.size() + " user(s)");

		final Map<String, Set<PermissionLevel>> map = Maps.newHashMap();

		for (User u : users) {

			map.put(u.getId(), u.getPermissionLevels());

		}

		dao.updatePermissionLevels(map);

		return true;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.IOException;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Properties;

import java.util.TreeMap;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.ResourceLoaderAware;

import org.springframework.core.io.Resource;

import org.springframework.core.io.ResourceLoader;

import org.springframework.core.io.support.ResourcePatternUtils;

import org.springframework.ui.ModelMap;

import com.google.common.collect.Maps;

import eu.dnetlib.conf.PropertyFetcher;

import eu.dnetlib.miscutils.collections.Pair;

/**

 * Modular UI that displays collected properties and shows winning ones.

 *

 * @author andrea

 *

 */

public class ContainerPropertiesController extends ModuleEntryPoint implements ResourceLoaderAware {

	@Autowired

	private PropertyFetcher propertyFetcher;

	private Properties propertyFetcherProps;

	private ResourceLoader resourceLoader;

	@Override

	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) throws Exception {

		propertyFetcherProps = propertyFetcher.getProps();

		map.addAttribute("properties", fetchProperties());

	}

	private Map<String, Map<String, Pair<String, Boolean>>> fetchProperties() throws IOException {

		// Map structure: { propertyKey | [PropertyValue | <Propertyfile | isChecked>] }

		final Map<String, Map<String, Pair<String, Boolean>>> propertiesMap = Maps.newTreeMap();

		// loop over all *.properties files

		for (Resource propFile : ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath*:/eu/dnetlib/**/*.properties")) {

			Properties properties = new Properties();

			properties.load(propFile.getInputStream());

			// loop over all properties set within a file

			for (Entry<Object, Object> e : properties.entrySet()) {

				Map<String, Pair<String, Boolean>> propValues;

				if (propertiesMap.containsKey(e.getKey())) {

					propValues = propertiesMap.get(e.getKey());

				} else {

					propValues = new TreeMap<String, Pair<String, Boolean>>();

				}

				Pair<String, Boolean> pair = new Pair<String, Boolean>(propFile.getFilename(), isWinning((String) e.getKey(), (String) e.getValue()));

				propValues.put((String) e.getValue(), pair);

				propertiesMap.put((String) e.getKey(), propValues);

			}

		}

		return propertiesMap;

	}

	/**

	 * Checks whether a given property-value is the one currently in use.

	 *

	 * @param prop

	 *            The property key

	 * @param value

	 *            The property value

	 * @return true/false

	 */

	private Boolean isWinning(final String prop, final String value) {

		String winningPropertyValue = propertyFetcherProps.getProperty(prop);

		if (value.equals(winningPropertyValue)) {

			return true;

		} else {

			return false;

		}

	}

	public ResourceLoader getResourceLoader() {

		return resourceLoader;

	}

	@Override

	public void setResourceLoader(final ResourceLoader resourceLoader) {

		this.resourceLoader = resourceLoader;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.List;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.functionality.modular.ui.users.PermissionLevel;

public class UsersController extends ModuleEntryPoint {

	private List<Map<String, String>> listAvailableLevels = Lists.newArrayList();; 

	@Override

	protected void initialize(ModelMap map, HttpServletRequest request,	HttpServletResponse response) throws Exception {

		map.addAttribute("availableLevels", listPermissionLevels());

	}

	private List<Map<String, String>> listPermissionLevels() {

		if (listAvailableLevels.isEmpty()) {

			for (PermissionLevel level : PermissionLevel.values()) {

				final Map<String, String> map = Maps.newHashMap();

				map.put("level", level.toString());

				map.put("label", level.getLabel());

				map.put("details", level.getDetails());

				listAvailableLevels.add(map);

			}

		}

		return listAvailableLevels;

	}

}

package eu.dnetlib.functionality.modular.ui.error;

import org.apache.commons.lang.exception.ExceptionUtils;

public class ErrorMessage {

	private String message;

	private String stacktrace;

	public ErrorMessage() {}

	public static ErrorMessage newInstance(final Exception e) {

		return new ErrorMessage(e.getMessage(), ExceptionUtils.getStackTrace(e));

	}

	public ErrorMessage(final String message, final String stacktrace) {

    	this.message = message;

    	this.stacktrace = stacktrace;

    }

	public String getMessage() {

		return message;

	}

	public void setMessage(final String message) {

		this.message = message;

	}

	public String getStacktrace() {

		return stacktrace;

	}

	public void setStacktrace(final String stacktrace) {

		this.stacktrace = stacktrace;

	}

}

package eu.dnetlib.functionality.modular.ui;

import org.springframework.http.HttpStatus;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.ResponseStatus;

import eu.dnetlib.functionality.modular.ui.error.ErrorMessage;

public abstract class AbstractAjaxController {

	@ExceptionHandler(Exception.class)

	@ResponseStatus(value=HttpStatus.INTERNAL_SERVER_ERROR)

	public @ResponseBody ErrorMessage handleException(final Exception e) {

		return ErrorMessage.newInstance(e);

	}

}

package eu.dnetlib.functionality.modular.ui.utils;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Autowired;

import com.google.common.collect.Lists;

import eu.dnetlib.enabling.common.Stoppable;

import eu.dnetlib.enabling.common.StoppableDetails;

import eu.dnetlib.enabling.common.StoppableDetails.StopStatus;

public class ShutdownUtils {

	@Autowired(required=false)

	private List<Stoppable> stoppables = Lists.newArrayList();

	private StopStatus status = StopStatus.RUNNING;

	private static final Log log = LogFactory.getLog(ShutdownUtils.class);

	public  List<StoppableDetails> listStoppableDetails() {

		final List<StoppableDetails> list = Lists.newArrayList();

		for (Stoppable s : stoppables) {

			list.add(s.getStopDetails());

		}

		return list;

	}

	public void stopAll() {

		this.status = StopStatus.STOPPING;

		for (Stoppable s : stoppables) {

			final StoppableDetails info = s.getStopDetails();

			if (info.getStatus() == StopStatus.RUNNING) {

				log.info("Stopping " + info.getName());

				s.stop();

			}

		}

	}

	public StopStatus currentStatus() {

		if (status == StopStatus.STOPPING) {

			int running = 0;

			for (Stoppable s : stoppables) {

				final StoppableDetails info = s.getStopDetails();

				if (info.getStatus() != StopStatus.STOPPED) {

					running++;

				}

			}

			if (running == 0) {

				status = StopStatus.STOPPED;

			}

		}

		return status;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.net.URLEncoder;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;

import org.springframework.beans.factory.BeanNameAware;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.ui.ModelMap;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.Controller;

import org.springframework.web.servlet.view.RedirectView;

import eu.dnetlib.functionality.modular.ui.users.AuthorizationManager;

import eu.dnetlib.functionality.modular.ui.users.User;

import eu.dnetlib.functionality.modular.ui.utils.ShutdownUtils;

public abstract class ModuleEntryPoint extends MenuEntry implements Controller, BeanNameAware {

	private String beanName;

	private boolean validMenuEntry = true;

	private String group;

	private int groupOrder = 50;

	@Value("${dnet.modular.ui.authentication.url}")

	private String authenticationUrl;

	@Value("${dnet.modular.ui.logout.url}")

	private String logoutUrl;

	@Value("${dnet.modular.ui.ribbon.environment}")

	private String environment;

	@Value("${dnet.modular.ui.ribbon.accent}")

	private String ribbonAccent;

	@Resource

	protected EntryPointsAggregator aggregator;

	@Resource

	private ShutdownUtils shutdownUtils;

	@Resource(name = "modularUiAuthorizationManager")

	protected AuthorizationManager authorizationManager;

	@Override

	public ModelAndView handleRequest(final HttpServletRequest request, final HttpServletResponse response) throws Exception {

		final User user = authorizationManager.obtainUserDetails(request);

		if (user != null) {

			final ModelAndView mv = new ModelAndView();

			final ModelMap map = mv.getModelMap();

			map.addAttribute("ui_menu", getMenu());

			map.addAttribute("ui_title", getTitle());

			map.addAttribute("ui_description", getDescription());

			map.addAttribute("ui_group", getGroup());

			map.addAttribute("ui_modules", aggregator.getMenus(user));

			map.addAttribute("environment", environment);

			map.addAttribute("ribbonAccent", ribbonAccent);

			switch (shutdownUtils.currentStatus()) {

			case STOPPING:

				map.addAttribute("ui_navbar_class", "navbar-system-stopping");

				map.addAttribute("ui_message", "stopping system");

				break;

			case STOPPED:

				map.addAttribute("ui_navbar_class", "navbar-system-stopped");

				map.addAttribute("ui_message", "system stopped");

				break;

			default:

				map.addAttribute("ui_navbar_class", "navbar-inverse");

				break;

			}

			String baseUrl = "";

			for (int i = 1; i < StringUtils.countMatches(beanName, "/"); i++) {

				baseUrl += "/..";

			}

			if (baseUrl.length() > 0) {

				baseUrl = baseUrl.substring(1);

			}

			map.addAttribute("ui_baseUrl", baseUrl);

			if ((logoutUrl != null) && !logoutUrl.isEmpty()) {

				map.addAttribute("ui_logoutUrl", logoutUrl);

			}

			map.addAttribute("ui_user", user);

			initialize(map, request, response);

			return mv;

		} else {

			final StringBuffer url = request.getRequestURL();

			final String queryString = request.getQueryString();

			if (queryString != null) {

				url.append('?');

				url.append(queryString);

			}

			return new ModelAndView(new RedirectView(authenticationUrl + "?url=" + URLEncoder.encode(url.toString(), "UTF-8")));

		}

	}

	abstract protected void initialize(ModelMap map, HttpServletRequest request, HttpServletResponse response) throws Exception;

	public String getBeanName() {

		return beanName;

	}

	@Override

	public void setBeanName(final String beanName) {

		this.beanName = beanName;

	}

	public String getGroup() {

		return group;

	}

	@Required

	public void setGroup(final String group) {

		this.group = group;

	}

	@Override

	public String getRelativeUrl() {

		return beanName;

	}

	public boolean isValidMenuEntry() {

		return validMenuEntry;

	}

	public void setValidMenuEntry(final boolean validMenuEntry) {

		this.validMenuEntry = validMenuEntry;

	}

	public int getGroupOrder() {

		return groupOrder;

	}

	public void setGroupOrder(final int groupOrder) {

		this.groupOrder = groupOrder;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

public enum PermissionLevel {

	SUPER_ADMIN("Super admin", "Authenticated user with ALL management rights"), 

	DS_ADMIN ("datasource administrator", "Authenticated user that can manage datasources"), 

	WF_ADMIN("workflow administrator", "Authenticated user that can manage workflows"),

	IS_ADMIN("information administrator", "Authenticated user that can update IS profiles"),

	USER("simple user", "Authenticated user with no management rights"), 

	GUEST ("guest", "Anonymous user");

	private String label;

	private String details;

	private PermissionLevel(final String label, final String details) {

		this.label = label;

		this.details = details;

	}

	public String getLabel() {

		return label;

	}

	public String getDetails() {

		return details;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

import java.util.Map;

import java.util.Set;

public interface AuthorizationDAO {

	void updatePermissionLevels(Map<String, Set<PermissionLevel>> map);

	Map<String, Set<PermissionLevel>> getPermissionLevels();

	Set<PermissionLevel> getPermissionLevels(String uid);

}

package eu.dnetlib.functionality.modular.ui.users;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Required;

import com.google.common.base.Joiner;

import com.google.common.base.Splitter;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.mongodb.BasicDBObject;

import com.mongodb.BasicDBObjectBuilder;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

public class MongoAuthorizationDAO implements AuthorizationDAO {

	private DB db;

	private static final String AUTH_COLL = "users";

	private static final Log log = LogFactory.getLog(MongoAuthorizationDAO.class);

	@Override

	public void updatePermissionLevels(Map<String, Set<PermissionLevel>> map) {

		final DBCollection coll = db.getCollection(AUTH_COLL);

		final List<DBObject> list = Lists.newArrayList();

		for (Entry<String, Set<PermissionLevel>> e : map.entrySet()) {

			final Map<String, String> m = Maps.newHashMap();

			m.put("uid" , e.getKey());

			m.put("levels", serializeLevels(e.getValue()));

			list.add(BasicDBObjectBuilder.start(m).get());

		}

		coll.remove(new BasicDBObject());

		coll.insert(list);

	}

	@Override

	public Map<String, Set<PermissionLevel>> getPermissionLevels() {

		final DBCollection coll = db.getCollection(AUTH_COLL);

		final DBCursor cur = coll.find();

		final Map<String, Set<PermissionLevel>> res = Maps.newHashMap();

		while (cur.hasNext()) {

			final DBObject o = cur.next();

			res.put((String) o.get("uid"), readLevels(o));

		}

		return res;

	}	

	@Override

	public Set<PermissionLevel> getPermissionLevels(String uid) {

		final DBCollection coll = db.getCollection(AUTH_COLL);

		final DBObject obj = coll.findOne(new BasicDBObject("uid", uid));

		return readLevels(obj);

	}

	private Set<PermissionLevel> readLevels(final DBObject obj) {

		final Set<PermissionLevel> set = new HashSet<PermissionLevel>();

		if (obj != null) {

			final Object levels = obj.get("levels");

			if (levels != null) {

				for (String s : Splitter.on(",").omitEmptyStrings().trimResults().split(levels.toString())) {

					try {

						set.add(PermissionLevel.valueOf(s));

					} catch (Throwable e) {

						log.error("Invalid permissionLevel: " + s);

					}

				}

			}

		}

		return set;

	}

	private String serializeLevels(Set<PermissionLevel> levels) {

		return Joiner.on(",").skipNulls().join(levels);

	}

	public DB getDb() {

		return db;

	}

	@Required

	public void setDb(DB db) {

		this.db = db;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

import javax.servlet.http.HttpServletRequest;

import com.google.common.collect.Sets;

public class MockAuthorizationManager implements AuthorizationManager {

	@Override

	public User obtainUserDetails(HttpServletRequest request) {

		final User userMock = new User();

		userMock.setId("mock");

		userMock.setFullname("Mock User");

		userMock.setPermissionLevels(Sets.newHashSet(PermissionLevel.SUPER_ADMIN));

		userMock.setEmail("mock@user.foo");

		return userMock;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

import java.security.Principal;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Required;

import com.google.common.collect.Sets;

public class SimpleAuthorizationManager implements AuthorizationManager {

	private AuthorizationDAO authorizationDAO;

	private String defaultSuperAdmin;

	@Override

	public User obtainUserDetails(final HttpServletRequest request) {

		final Principal principal = request.getUserPrincipal();

		final User user = new User();

		if (principal != null) {

	        final String username = principal.getName();

	        if (username != null) {

	        	user.setId(username);

	        	user.setFullname(username);

	        	user.setPermissionLevels(authorizationDAO.getPermissionLevels(username));

	        	if (username.equals(getDefaultSuperAdmin())) {

	        		user.getPermissionLevels().add(PermissionLevel.SUPER_ADMIN);

	        	}

	        } else {

	        	user.setId("anonymous");

	        	user.setFullname("anonymous");

	        	user.setPermissionLevels(Sets.newHashSet(PermissionLevel.GUEST));

	        }

	    }

		return user;

	}

	public AuthorizationDAO getAuthorizationDAO() {

		return authorizationDAO;

	}

	@Required

	public void setAuthorizationDAO(AuthorizationDAO authorizationDAO) {

		this.authorizationDAO = authorizationDAO;

	}

	public String getDefaultSuperAdmin() {

		return defaultSuperAdmin;

	}

	@Required

	public void setDefaultSuperAdmin(String defaultSuperAdmin) {

		this.defaultSuperAdmin = defaultSuperAdmin;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

import java.util.Set;

public interface AccessLimited {

	public Set<PermissionLevel> getPermissionLevels();

}

package eu.dnetlib.functionality.modular.ui.users;

import java.net.URLDecoder;

import java.security.KeyFactory;

import java.security.PublicKey;

import java.security.Signature;

import java.security.spec.KeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.Map;

import javax.servlet.http.Cookie;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Required;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import com.google.gson.Gson;

public class SimpleSSOAuthorizationManager implements AuthorizationManager {

	private static final Log log = LogFactory.getLog(SimpleSSOAuthorizationManager.class);

	private Resource pubKeyFile = new ClassPathResource("/eu/dnetlib/functionality/modular/ui/users/pubkey.der");

	private String pubKeyAlgo = "RSA";

	private String signatureAlgo = "SHA1withRSA";

	private PublicKey publicKey;

	private AuthorizationDAO authorizationDAO;

	private String defaultSuperAdmin;

	@Override

	public User obtainUserDetails(final HttpServletRequest request) {

		if (request.getCookies() != null) {

			for (Cookie cookie : request.getCookies()) {

				if (cookie.getName().equalsIgnoreCase("rinfra-user")) {

					try {

						return processCookie(cookie.getValue());

					} catch (Exception e) {

						log.error("Error processing cookie: " + cookie.getValue(), e);

						return null;

					}

				}

			}

		}

		return null;

	}

	private User processCookie(final String s) throws Exception {

		if (s == null || s.isEmpty()) {

			return null;

		}

		final Gson gson = new Gson();

		final Map<?,?> map = gson.fromJson(new String(Base64.decodeBase64(URLDecoder.decode(s.trim(), "UTF-8"))), Map.class);

		final String message = (String) map.get("payload");

		final String signature = (String) map.get("signature");

		if (isValidMessage(message, signature)) {

			final Map<?,?> userMap = gson.fromJson(message, Map.class);

			if (userMap.containsKey("uid")) {

				final String uid = (String) userMap.get("uid");

				final User user = new User(uid);

				user.setEmail((String) userMap.get("email"));

				user.setFullname(userMap.containsKey("fullname") ? (String) userMap.get("fullname") : uid);

				user.setPermissionLevels(authorizationDAO.getPermissionLevels(uid));

				if (isDefaultSuperAdmin(uid)) {

					user.getPermissionLevels().add(PermissionLevel.SUPER_ADMIN);

				}

				return user;

			}

		}

		return null;

	}

	private boolean isDefaultSuperAdmin(final String uid) {

		return (uid != null && !uid.isEmpty() && uid.equals(getDefaultSuperAdmin()));

	}

	protected boolean isValidMessage(final String message, final String signature) {

		log.info("checking message " + message + " with sig " + signature);

		if (message == null || message.isEmpty() || signature == null || signature.isEmpty()) {

			log.error("Null  or empty values in message or signature");

			return false;

		}

		try {

			final Signature sg = Signature.getInstance(getSignatureAlgo());

			sg.initVerify(getPublicKey());

			sg.update(message.getBytes());

			return sg.verify(Hex.decodeHex(signature.toCharArray()));

		} catch(Exception e) {

			log.error("Error verifyng signature", e);

			return false;

		}

	}

	public void init() throws Exception {

		final byte[] keyBytes = IOUtils.toByteArray(getPubKeyFile().getInputStream());

		final KeySpec spec = new X509EncodedKeySpec(keyBytes);

		setPublicKey(KeyFactory.getInstance(getPubKeyAlgo()).generatePublic(spec));

	}

	public Resource getPubKeyFile() {

		return pubKeyFile;

	}

	@Required

	public void setPubKeyFile(Resource pubKeyFile) {

		this.pubKeyFile = pubKeyFile;

	}

	public String getPubKeyAlgo() {

		return pubKeyAlgo;

	}

	@Required

	public void setPubKeyAlgo(String pubKeyAlgo) {

		this.pubKeyAlgo = pubKeyAlgo;

	}

	public String getSignatureAlgo() {

		return signatureAlgo;

	}

	@Required

	public void setSignatureAlgo(String signatureAlgo) {

		this.signatureAlgo = signatureAlgo;

	}

	public PublicKey getPublicKey() {

		return publicKey;

	}

	public void setPublicKey(PublicKey publicKey) {

		this.publicKey = publicKey;

	}

	public AuthorizationDAO getAuthorizationDAO() {

		return authorizationDAO;

	}

	@Required

	public void setAuthorizationDAO(AuthorizationDAO authorizationDAO) {

		this.authorizationDAO = authorizationDAO;

	}

	public String getDefaultSuperAdmin() {

		return defaultSuperAdmin;

	}

	@Required

	public void setDefaultSuperAdmin(String defaultSuperAdmin) {

		this.defaultSuperAdmin = defaultSuperAdmin;

	}

}

package eu.dnetlib.functionality.modular.ui.users;

import javax.servlet.http.HttpServletRequest;

public interface AuthorizationManager {

	User obtainUserDetails(HttpServletRequest request);

}

package eu.dnetlib.functionality.modular.ui.users;

import java.util.Set;

public class User implements Comparable<User> {

	private String id;

	private String fullname;

	private String email;

	private Set<PermissionLevel> permissionLevels;

	public User() {}

	public User(final String id) {

		this.id = id;

	}

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public String getFullname() {

		return fullname;

	}

	public void setFullname(String fullname) {

		this.fullname = fullname;

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(String email) {

		this.email = email;

	}

	public Set<PermissionLevel> getPermissionLevels() {

		return permissionLevels;

	}

	public void setPermissionLevels(Set<PermissionLevel> permissionLevels) {

		this.permissionLevels = permissionLevels;

	}

	@Override

	public int compareTo(final User o) {

		return getId().compareTo(o.getId());

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.Set;

import org.apache.commons.lang.math.NumberUtils;

import org.springframework.beans.factory.annotation.Required;

import eu.dnetlib.functionality.modular.ui.users.AccessLimited;

import eu.dnetlib.functionality.modular.ui.users.PermissionLevel;

public abstract class MenuEntry implements Comparable<MenuEntry>, AccessLimited {

	private String menu;

	private String title;

	private String description;

	private int order = 50;

	private Set<PermissionLevel> permissionLevels;

	@Override

	public int compareTo(MenuEntry o) {

		return NumberUtils.compare(this.getOrder(), o.getOrder());

	}

	abstract public String getRelativeUrl();

	public String getMenu() {

		return menu;

	}

	@Required

	public void setMenu(String menu) {

		this.menu = menu;

	}

	public String getTitle() {

		return title;

	}

	@Required

	public void setTitle(String title) {

		this.title = title;

	}

	public String getDescription() {

		return description;

	}

	@Required

	public void setDescription(String description) {

		this.description = description;

	}

	@Override

	public Set<PermissionLevel> getPermissionLevels() {

		return permissionLevels;

	}

	@Required

	public void setPermissionLevels(Set<PermissionLevel> permissionLevels) {

		this.permissionLevels = permissionLevels;

	}

	public int getOrder() {

		return order;

	}

	public void setOrder(int order) {

		this.order = order;

	}

}

package eu.dnetlib.functionality.modular.ui;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

public class UserDetailsController extends ModuleEntryPoint {

	@Override

	protected void initialize(ModelMap map, HttpServletRequest request,	HttpServletResponse response) throws Exception {}

}

package eu.dnetlib.functionality.modular.ui;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

public class MainController extends ModuleEntryPoint {

	@Override

	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) {}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.List;

import org.apache.commons.lang.math.NumberUtils;

import org.springframework.beans.factory.annotation.Required;

public abstract class AbstractMenu implements Comparable<AbstractMenu> {

	private String title;		

	abstract public int getOrder();

	abstract public List<? extends MenuEntry> getEntries();

	@Override

	public int compareTo(final AbstractMenu menu) {

		return NumberUtils.compare(getOrder(), menu.getOrder());

	}

	public String getTitle() {

		return title;

	}

	@Required

	public void setTitle(String title) {

		this.title = title;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;

import eu.dnetlib.enabling.common.StoppableDetails;

import eu.dnetlib.functionality.modular.ui.utils.ShutdownUtils;

@Controller

public class PrepareShutdownInternalController {

	@Resource

	private ShutdownUtils shutdownUtils;

	@RequestMapping("/ui/shutdown/listStoppableDetails.json")

	public @ResponseBody List<StoppableDetails> listStoppableDetails() {

		return shutdownUtils.listStoppableDetails();

	}

	@RequestMapping("/ui/shutdown/stopAll.do")

	public @ResponseBody boolean stopAll() {

		shutdownUtils.stopAll();

		return true;

	}

}