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.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.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.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.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;

	@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));

			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(String beanName) {

		this.beanName = beanName;

	}

	public String getGroup() {

		return group;

	}

	@Required

	public void setGroup(String group) {

		this.group = group;

	}

	@Override

	public String getRelativeUrl() {

		return beanName;

	}

	public boolean isValidMenuEntry() {

		return validMenuEntry;

	}

	public void setValidMenuEntry(boolean validMenuEntry) {

		this.validMenuEntry = validMenuEntry;

	}

	public int getGroupOrder() {

		return groupOrder;

	}

	public void setGroupOrder(int groupOrder) {

		this.groupOrder = groupOrder;

	}

}

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;

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.StringReader;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.springframework.stereotype.Controller;

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

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

import com.google.gson.Gson;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.is.registry.rmi.ISRegistryService;

import eu.dnetlib.enabling.tools.ServiceLocator;

@Controller

public class CommonController {

	@Resource(name="lookupLocator")

	private ServiceLocator<ISLookUpService> lookupLocator;

	@Resource(name="registryLocator")

	private ServiceLocator<ISRegistryService> registryLocator;

	@RequestMapping(value="/ui/**/getProfile")

	public void getProfile(HttpServletResponse res, 

			@RequestParam(value="id", required=true) String id) throws Exception {

		res.setContentType("text/xml");

		String profile = lookupLocator.getService().getResourceProfile(id);

		IOUtils.copy(new StringReader(profile), res.getOutputStream());

	}

	@RequestMapping(value="/ui/**/getSchema")

	public void getSchema(HttpServletResponse res, 

				@RequestParam(value="name", required=true) String name) throws Exception {

		res.setContentType("text/xml");

		String schema = lookupLocator.getService().getResourceTypeSchema(name);

		IOUtils.copy(new StringReader(schema), res.getOutputStream());

	}

	@RequestMapping(value="/ui/**/validateProfile")

	public void validate(HttpServletResponse res, 

			@RequestParam(value="id", required=true) String id) throws Exception {

		String newId = registryLocator.getService().validateProfile(id);

		IOUtils.copy(new StringReader(new Gson().toJson(newId)), res.getOutputStream());

	}

	@RequestMapping(value="/ui/**/invalidateProfile")

	public void invalidateProfile(HttpServletResponse res, 

			@RequestParam(value="id", required=true) String id) throws Exception {

		String newId = registryLocator.getService().invalidateProfile(id);

		IOUtils.copy(new StringReader(new Gson().toJson(newId)), res.getOutputStream());

	}

	@RequestMapping(value="/ui/**/deleteProfile")

	public void deleteProfile(HttpServletResponse res, 

			@RequestParam(value="id", required=true) String id) throws Exception {

		boolean b = registryLocator.getService().deleteProfile(id);

		IOUtils.copy(new StringReader(new Gson().toJson(b)), res.getOutputStream());

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.Collections;

import java.util.List;

import com.google.common.collect.Lists;

public class ModulesMenu extends AbstractMenu {

	private int order = Integer.MAX_VALUE;

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

	public ModulesMenu(final String title) {

		super();

		setTitle(title);

	}

	public void addEntry(final ModuleEntryPoint entry) {

		entries.add(entry);

	}

	public void complete() {

		Collections.sort(entries);

		for (ModuleEntryPoint e : entries) {

			if (e.getGroupOrder() < this.order) {

				this.order = e.getGroupOrder();

			}

		}

	}

	@Override

	public int getOrder() {

		return order;

	}

	@Override

	public List<? extends MenuEntry> getEntries() {

		return entries;

	}

}

package eu.dnetlib.functionality.modular.ui;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

public class PrepareShutdownController extends ModuleEntryPoint {

	@Override

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

}

dnet.modular.ui.authorization.manager = mockUserAuthenticationManager

dnet.modular.ui.authorization.dao     = mongoAuthorizationDao

dnet.modular.ui.authentication.url    = http://146.48.87.97/

dnet.modular.ui.logout.url            = http://146.48.87.97/?logout

dnet.modular.ui.auth.signature.algo   = SHA1withRSA

dnet.modular.ui.auth.pubkey.derFile   = classpath:/eu/dnetlib/functionality/modular/ui/users/pubkey.der

dnet.modular.ui.auth.pubkey.algo      = RSA

dnet.modular.ui.authorization.default.superAdmin = michele.artini

dnet.modular.ui.authorization.mongo.host = localhost

dnet.modular.ui.authorization.mongo.port = 27017

dnet.modular.ui.authorization.mongo.db = dnet_auth

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="shutdownUtils" class="eu.dnetlib.functionality.modular.ui.utils.ShutdownUtils"/>

	<bean id="simpleSSOAuthorizationManager" 

		class="eu.dnetlib.functionality.modular.ui.users.SimpleSSOAuthorizationManager" 

		init-method="init"

		p:pubKeyAlgo="${dnet.modular.ui.auth.pubkey.algo}" 

		p:pubKeyFile="${dnet.modular.ui.auth.pubkey.derFile}" 

		p:signatureAlgo="${dnet.modular.ui.auth.signature.algo}" 

		p:authorizationDAO-ref="modularUiAuthorizationDao" 

		p:defaultSuperAdmin="${dnet.modular.ui.authorization.default.superAdmin}"/>

	<bean id="modularUiMongoServer" class="com.mongodb.Mongo">

		<constructor-arg index="0" type="com.mongodb.ServerAddress">

			<bean class="com.mongodb.ServerAddress">

				<constructor-arg index="0" value="${dnet.modular.ui.authorization.mongo.host}" />

				<constructor-arg index="1" value="${dnet.modular.ui.authorization.mongo.port}" />

			</bean>

		</constructor-arg>

	</bean>

	<bean id="mongoAuthorizationDao" 

		class="eu.dnetlib.functionality.modular.ui.users.MongoAuthorizationDAO">

		<property name="db">

			<bean factory-bean="modularUiMongoServer" factory-method="getDB">

				<constructor-arg index="0" value="${dnet.modular.ui.authorization.mongo.db}" />

			</bean>

		</property>

	</bean> 

	<bean id="mockUserAuthenticationManager" class="eu.dnetlib.functionality.modular.ui.users.MockAuthorizationManager" />

	<bean id="simpleAuthenticationManager" class="eu.dnetlib.functionality.modular.ui.users.SimpleAuthorizationManager" 

		p:authorizationDAO-ref="modularUiAuthorizationDao"

		p:defaultSuperAdmin="${dnet.modular.ui.authorization.default.superAdmin}"/>	

	<alias name="${dnet.modular.ui.authorization.manager}" alias="modularUiAuthorizationManager"/>

	<alias name="${dnet.modular.ui.authorization.dao}" alias="modularUiAuthorizationDao"/>

</beans>

<!DOCTYPE html>

<html lang="en">

<head>

	<title>$if(ui_title)$$ui_title$$else$No title$endif$</title>

	<meta charset="utf-8">

	<meta http-equiv="X-UA-Compatible" content="IE=edge">

	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

	<link rel="stylesheet" type="text/css" media="screen" href="../resources/css/bootstrap-spacelab.min.css">

	<link rel="stylesheet" type="text/css" href="../resources/css/custom.css">

	<link rel="stylesheet" type="text/css" media="all"   href="../resources/css/jquery.pnotify.default.css">

	<script type="text/javascript" src="../resources/js/jquery-1.11.0.min.js" ></script>

	<script type="text/javascript" src="../resources/js/bootstrap.min.js" ></script>

	<script type="text/javascript" src="../resources/js/spin.js" ></script>

	<script type="text/javascript" src="../resources/js/jquery.pnotify.min.js"></script>

	<script type="text/javascript" src="../resources/js/custom.js"></script>

	<meta name="viewport" content="width=device-width, initial-scale=1.0">

	$header$

</head>

<body role="document">

	<div class="navbar $ui_navbar_class$ navbar-fixed-top" role="navigation">

		<div class="container-fluid">

			<!-- Brand and toggle get grouped for better mobile display -->

			<div class="navbar-header">

				<button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#collapsedNavbar">

					<span class="sr-only">Toggle navigation</span>

					<span class="icon-bar"></span>

					<span class="icon-bar"></span>

					<span class="icon-bar"></span>

				</button>

				<a class="navbar-brand" href="#">D-Net</a>

			</div>

			<!-- Collect the nav links, forms, and other content for toggling -->

			<div class="collapse navbar-collapse" id="collapsedNavbar">

				<ul class="nav navbar-nav">

				$ui_modules:{k|

				   <li class="dropdown">

						<a href="#" class="dropdown-toggle" data-toggle="dropdown">$k.title$ <b class="caret"></b></a>

						<ul class="dropdown-menu">

							$k.entries:{ep|<li><a href="$ui_baseUrl$$ep.relativeUrl$">$ep.menu$</a></li> }$

						</ul>

					</li>

				}$

				</ul>

				$if(ui_user)$

					<ul class="nav navbar-nav navbar-right">

						<li class="dropdown">

							<a href="#" class="dropdown-toggle" data-toggle="dropdown">$ui_user.fullname$ <b

									class="caret"></b></a>

							<ul class="dropdown-menu">

								<li><a href="userDetails.do">details</a></li>

								$if(ui_logoutUrl)$

									<li class="divider"></li>

									<li><a href="$ui_logoutUrl$">logout</a></li>

								$endif$

							</ul>

						</li>

					</ul>

				$endif$

			</div><!-- /.navbar-collapse -->

		</div><!-- /.container-fluid -->

	</div>

	$if(ui_message)$

		<div style="position: absolute; top: -4px; right: 10px; z-index: 99999;

			border: 1px solid grey; 

			background-color: #ffffff;

			padding: 3px 20px;

			opacity: 0.9;

			border-radius: 6px;

			font-size: 11px;">$ui_message$</div>

	$endif$

	<!-- Le spinning indicator for operation wait -->

	<div id="spinnerdiv" class="overlaydiv">

		<span class="grayRectangle"><!--The spinner is added on loading here--></span>

	</div>

	<!-- Le main container -->

	<div role="main" class="container-fluid" style="margin-top: 40px; margin-bottom: 70px;">

		<div class="row">

			<div class="col-xs-12">

				<h3 class="page-header">$if(ui_title)$$ui_title$$else$No title$endif$</h3>