D-Net

{

"type_source": "SVN",

"goal": "package -U source:jar",

"url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet50/modules/dnet-modular-uis/branches/saxonHE",

"deploy_repository": "dnet5-snapshots",

"version": "5",

"mail": "alessia.bardi@isti.cnr.it",

"deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet5-snapshots",

"name": "dnet-modular-uis-saxonHE"

}

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

import java.util.Date;

import com.google.gson.Gson;

import eu.dnetlib.rmi.datasource.DatasourceDesc;

import org.junit.Assert;

import org.junit.Test;

/**

 * Created by Alessia Bardi on 11/05/2017.

 *

 * @author Alessia Bardi

 */

public class DatasourceTest {

	String repoJson = "{\"latitude\":\"0.0\",\"longitude\":\"0.0\",\"timezone\":\"0.0\",\"id\":\"parthenos___::ehri\",\"officialName\":\"European Holocaust Research Infrastructure\",\"englishName\":\"European Holocaust Research Infrastructure\",\"organization\":\"EHRI\",\"datasourceClass\":\"dnet:repository\",\"websiteUrl\":\"https://www.ehri-project.eu/\",\"contactEmail\":\"charles.riondet@inria.fr\",\"countryCode\":\"EU\",\"namespacePrefix\":\"ehri________\"}";

	@Test

	public void testGsonParse(){

		final DatasourceDesc ds = new Gson().fromJson(repoJson, DatasourceDesc.class);

		ds.setDateOfCollection(new Date());

		Assert.assertNotNull(ds);

		System.out.println(ds);

	}

}

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

import java.util.ArrayList;

import java.util.List;

public class Term implements Comparable<Term> {

	private String englishName;

	private String nativeName;

	private String encoding;

	private String code;

	private List<Synonym> synonyms = new ArrayList<Synonym>();

	private List<Relation> relations = new ArrayList<Relation>();

	public Term() {}

	public Term(String englishName, String nativeName, String encoding,

			String code, List<Synonym> synonyms, List<Relation> relations) {

		super();

		this.englishName = englishName;

		this.nativeName = nativeName;

		this.encoding = encoding;

		this.code = code;

		this.synonyms = synonyms;

		this.relations = relations;

	}

	public String getEnglishName() {

		return englishName;

	}

	public void setEnglishName(String englishName) {

		this.englishName = englishName;

	}

	public String getNativeName() {

		return nativeName;

	}

	public void setNativeName(String nativeName) {

		this.nativeName = nativeName;

	}

	public String getEncoding() {

		return encoding;

	}

	public void setEncoding(String encoding) {

		this.encoding = encoding;

	}

	public String getCode() {

		return code;

	}

	public void setCode(String code) {

		this.code = code;

	}

	public List<Synonym> getSynonyms() {

		return synonyms;

	}

	public void setSynonyms(List<Synonym> synonyms) {

		this.synonyms = synonyms;

	}

	public List<Relation> getRelations() {

		return relations;

	}

	public void setRelations(List<Relation> relations) {

		this.relations = relations;

	}

	@Override

	public int compareTo(Term o) {

		return englishName.compareTo(o.getEnglishName());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Vocabulary implements Comparable<Vocabulary> {

	private String id;

	private String name;

	private String description;

	private String code;

	public Vocabulary() {}

	public Vocabulary(String id, String name, String description, String code) {

		super();

		this.id = id;

		this.name = name;

		this.description = description;

		this.code = code;

	}

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getCode() {

		return code;

	}

	public void setCode(String code) {

		this.code = code;

	}

	@Override

	public int compareTo(Vocabulary o) {

		return name.compareTo(o.getName());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Synonym implements Comparable<Synonym> {

	private String term;

	private String encoding;	

	public Synonym() {}

	public Synonym(String term, String encoding) {

		super();

		this.term = term;

		this.encoding = encoding;

	}

	public String getTerm() {

		return term;

	}

	public void setTerm(String term) {

		this.term = term;

	}

	public String getEncoding() {

		return encoding;

	}

	public void setEncoding(String encoding) {

		this.encoding = encoding;

	}

	@Override

	public int compareTo(Synonym o) {

		return term.compareTo(o.getTerm());

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.model;

public class Relation implements Comparable<Relation> {

	private String type;

	private String code;

	public Relation() {}

	public Relation(final String type, final String code) {

		super();

		this.type = type;

		this.code = code;

	}

	public String getType() {

		return type;

	}

	public void setType(final String type) {

		this.type = type;

	}

	@Override

	public int compareTo(final Relation o) {

		return code.compareTo(o.getCode());

	}

	public String getCode() {

		return code;

	}

	public void setCode(final String code) {

		this.code = code;

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

import java.io.IOException;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Relation;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Synonym;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.rmi.enabling.*;

import org.antlr.stringtemplate.StringTemplate;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringEscapeUtils;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

public class RegistryServiceVocabularyDAO extends VocabularyDAO {

	@Override

	public List<Vocabulary> getVocabularies() throws VocabularyException {

		try {

			final String query =

					"for $x in collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType') order by $x//VOCABULARY_NAME "

							+ "return concat ($x//RESOURCE_IDENTIFIER/@value,' §§§ ',$x//VOCABULARY_NAME,' §§§ ',$x//VOCABULARY_DESCRIPTION,' §§§ ',$x//VOCABULARY_NAME/@code)";

			final List<Vocabulary> vocabularies = Lists.transform(this.serviceLocator.getService(ISLookUpService.class).quickSearchProfile(query),

					s -> {

						final String[] tokens = s.split("§§§");

						return new Vocabulary(tokens[0].trim(), tokens[1].trim(), tokens[2].trim(), tokens[3].trim());

					});

			return vocabularies;

		} catch (final ISLookUpException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public List<Term> getTerms(final String vocabularyId) throws VocabularyException {

		try {

			final String profile = this.serviceLocator.getService(ISLookUpService.class).getResourceProfile(vocabularyId);

			final Document doc = new SAXReader().read(new StringReader(profile));

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

			for (final Object t : doc.selectNodes("//TERM")) {

				final Element termNode = (Element) t;

				final String code = termNode.valueOf("@code");

				if (!terms.containsKey(code)) {

					final Term term = new Term();

					term.setEnglishName(termNode.valueOf("@english_name"));

					term.setNativeName(termNode.valueOf("@native_name"));

					term.setEncoding(termNode.valueOf("@encoding"));

					term.setCode(code);

					term.setSynonyms(new ArrayList<Synonym>());

					term.setRelations(new ArrayList<Relation>());

					terms.put(code, term);

				}

				final Term term = terms.get(code);

				for (final Object s : termNode.selectNodes(".//SYNONYM")) {

					final Element synNode = (Element) s;

					final Synonym syn = new Synonym();

					syn.setTerm(synNode.valueOf("@term"));

					syn.setEncoding(synNode.valueOf("@encoding"));

					term.getSynonyms().add(syn);

				}

				for (final Object r : termNode.selectNodes(".//RELATION")) {

					final Element relNode = (Element) r;

					final Relation rel = new Relation();

					rel.setCode(relNode.valueOf("@code"));

					rel.setType(relNode.valueOf("@type"));

					term.getRelations().add(rel);

				}

				Collections.sort(term.getSynonyms());

				Collections.sort(term.getRelations());

			}

			final List<Term> list = Lists.newArrayList(terms.values());

			Collections.sort(list);

			return list;

		} catch (final ISLookUpDocumentNotFoundException e) {

			throw new VocabularyException(e);

		} catch (final ISLookUpException e) {

			throw new VocabularyException(e);

		} catch (final DocumentException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void commitTerms(final List<Term> terms, final String vocabularyId) throws VocabularyException {

		try {

			// prepare terms for XML

			for (final Term t : terms) {

				t.setCode(StringEscapeUtils.escapeXml11(t.getCode()));

				t.setEncoding(StringEscapeUtils.escapeXml11(t.getEncoding()));

				t.setEnglishName(StringEscapeUtils.escapeXml11(t.getEnglishName()));

				t.setNativeName(StringEscapeUtils.escapeXml11(t.getNativeName()));

				for (final Synonym s : t.getSynonyms()) {

					s.setEncoding(StringEscapeUtils.escapeXml11(s.getEncoding()));

					s.setTerm(StringEscapeUtils.escapeXml11(s.getTerm()));

				}

				for (final Relation r : t.getRelations()) {

					r.setType(StringEscapeUtils.escapeXml11(r.getType()));

					r.setCode(StringEscapeUtils.escapeXml11(r.getCode()));

				}

			}

			final StringTemplate st =

					new StringTemplate(IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/templates/terms.xml.st")));

			st.setAttribute("terms", terms);

			this.serviceLocator.getService(ISRegistryService.class).updateProfileNode(vocabularyId, "//TERMS", st.toString());

		} catch (final IOException e) {

			throw new VocabularyException(e);

		} catch (final ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void commitVocabularyInfo(final Vocabulary voc, final String vocabularyId) throws VocabularyException {

		try {

			String xml = "<VOCABULARY_DESCRIPTION>{desc}</VOCABULARY_DESCRIPTION>";

			xml = xml.replace("{desc}", StringEscapeUtils.escapeXml11(voc.getDescription()));

			this.serviceLocator.getService(ISRegistryService.class).updateProfileNode(vocabularyId, "//VOCABULARY_DESCRIPTION", xml);

		} catch (final ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public String createVocabulary(final Vocabulary voc) throws VocabularyException {

		try {

			final StringTemplate st = new StringTemplate(

					IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/templates/vocabulary.xml.st")));

			st.setAttribute("name", voc.getName());

			st.setAttribute("description", voc.getDescription());

			st.setAttribute("code", voc.getCode());

			st.setAttribute("date", DateUtils.now_ISO8601());

			final String newVocabularyId = this.serviceLocator.getService(ISRegistryService.class).registerProfile(st.toString());

			return newVocabularyId;

		} catch (final IOException e) {

			throw new VocabularyException(e);

		} catch (final ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

	@Override

	public void dropVocabulary(final String vocabularyId) throws VocabularyException {

		try {

			this.serviceLocator.getService(ISRegistryService.class).deleteProfile(vocabularyId);

		} catch (final ISRegistryDocumentNotFoundException e) {

			throw new VocabularyException(e);

		} catch (final ISRegistryException e) {

			throw new VocabularyException(e);

		}

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

public class VocabularyException extends Exception {

	/**

	 *

	 */

	private static final long serialVersionUID = 1L;

	Exception exception;

	public VocabularyException(final Exception e) {

		this.exception = e;

	}

}

package eu.dnetlib.functionality.modular.ui.vocabularies.persistence;

import java.util.List;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

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

public abstract class VocabularyDAO {

	@Autowired

	protected UniqueServiceLocator serviceLocator;

	public abstract List<Vocabulary> getVocabularies() throws VocabularyException;

	public abstract List<Term> getTerms(final String vocabularyId) throws VocabularyException;

	public abstract void commitTerms(final List<Term> terms, final String vocabularyId) throws VocabularyException;

	public abstract void commitVocabularyInfo(final Vocabulary voc, final String vocabularyId) throws VocabularyException;

	public abstract String createVocabulary(final Vocabulary voc) throws VocabularyException;

	public abstract void dropVocabulary(final String vocabularyId) throws VocabularyException;

}

package eu.dnetlib.functionality.modular.ui.vocabularies.controllers;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.springframework.ui.ModelMap;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

public class EntryPointController extends ModuleEntryPoint {

	@Override

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

		map.addAttribute("validRelations", IOUtils.toString(getClass().getResourceAsStream("/eu/dnetlib/functionality/modular/ui/term_relations.json"))); 

	}

}	

package eu.dnetlib.functionality.modular.ui.vocabularies.controllers;

import java.util.List;

import javax.annotation.Resource;

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

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

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Term;

import eu.dnetlib.functionality.modular.ui.vocabularies.model.Vocabulary;

import eu.dnetlib.functionality.modular.ui.vocabularies.persistence.VocabularyDAO;

import eu.dnetlib.functionality.modular.ui.vocabularies.persistence.VocabularyException;

/**

 * Web controller for the UI

 *

 * @author Andrea Mannocci

 */

@Controller

public class VocabulariesController extends VocabularyDAO {

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

	@Resource(name = "vocabularyDao")

	private VocabularyDAO dao;

	/**

	 * Returns all vocabularies serialized in json. Invoked by angularJS

	 */

	@Override

	@RequestMapping("/ui/vocabularies.json")

	public @ResponseBody List<Vocabulary> getVocabularies() throws VocabularyException {

		log.info("vocabularies.json");

		return dao.getVocabularies();

	}

	/**

	 * Returns all terms and their synonyms belonging to a vocabulary. Invoked by AngularJS

	 */

	@Override

	@RequestMapping("/ui/terms.json")

	public @ResponseBody List<Term> getTerms(@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("terms.json?vocabularyId=" + vocabularyId);

		return dao.getTerms(vocabularyId);

	}

	@Override

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

	public @ResponseBody void commitTerms(@RequestBody(required = true) final List<Term> terms,

			@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("committing vocabulary id = " + vocabularyId);

		dao.commitTerms(terms, vocabularyId);

	}

	@Override

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

	public @ResponseBody void commitVocabularyInfo(@RequestBody(required = true) final Vocabulary voc,

			@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("committing vocabulary info id = " + vocabularyId);

		dao.commitVocabularyInfo(voc, vocabularyId);

	}

	@Override

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

	public @ResponseBody String createVocabulary(@RequestBody(required = true) final Vocabulary voc) throws VocabularyException {

		log.info("create vocabulary");

		String vocId = dao.createVocabulary(voc);

		return vocId;

	}

	@Override

	@RequestMapping(value = "/ui/dropVocabulary", method = RequestMethod.GET)

	public @ResponseBody void dropVocabulary(@RequestParam(value = "vocabularyId", required = true) final String vocabularyId) throws VocabularyException {

		log.info("delete vocabulary id=" + vocabularyId);

		dao.dropVocabulary(vocabularyId);

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.File;

import java.util.Enumeration;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.FileAppender;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

import org.springframework.ui.ModelMap;

public class DnetLogController extends ModuleEntryPoint {

	@Override

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

		map.addAttribute("logFile", getLogFileName());

	}

	public static String getLogFileName() {

		final Logger logger = LogManager.getRootLogger();

		final Enumeration<?> appenders = logger.getAllAppenders();

		while (appenders.hasMoreElements()) {

			final Object app = appenders.nextElement();

			if (app instanceof FileAppender) { return new File(((FileAppender) app).getFile()).getAbsolutePath(); }

		}

		return "";

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.util.*;

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;

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

public class EntryPointsAggregator {

	@Autowired(required=false)

	private List<ModuleEntryPoint> entryPoints = new ArrayList<>();

	@Autowired(required=false)

	private List<AbstractMenu> otherMenus = new ArrayList<>();

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

		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 = new ArrayList<>();

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

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Properties;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.core.io.Resource;

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

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

import org.springframework.ui.ModelMap;

import com.google.common.collect.Maps;

import eu.dnetlib.conf.PropertyFetcher;

import eu.dnetlib.conf.WebappContextPropertyLocationFactory;

/**

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

 *

 * @author Andrea Mannocci

 */

public class ContainerPropertiesController extends ModuleEntryPoint {

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

	private final ResourcePatternResolver pathResolver = new PathMatchingResourcePatternResolver();

	@Autowired

	private PropertyFetcher propertyFetcher;

	private Properties propertyFetcherProps;

	@Autowired

	private WebappContextPropertyLocationFactory propertyLocations;

	@Override

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

		this.propertyFetcherProps = this.propertyFetcher.getProps();

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

	}

	private Map<String, List<PropertyInfo>> fetchProperties() throws IOException {

		final Map<String, List<PropertyInfo>> propertiesMap = Maps.newTreeMap();

		// cycle over all property locations know to dnet

		for (final String location : this.propertyLocations.getLocations()) {

			log.debug(String.format("Loading properties from %s", location));

			// loop over all *.properties files matching the location

			for (final Resource propertyFile : this.pathResolver.getResources(location)) {

				final Properties properties = new Properties();

				log.debug(String.format("URL: %s", propertyFile.getURL()));

				properties.load(propertyFile.getInputStream());

				// loop over all properties set within a property file file

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

					List<PropertyInfo> propertyInfoList;

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

						propertyInfoList = propertiesMap.get(property.getKey());

					} else {

						propertyInfoList = new ArrayList<>();

					}

					propertyInfoList.add(new PropertyInfo((String) property.getValue(), propertyFile.getFilename(),

							isWinning((String) property.getKey(), (String) property.getValue())));

					propertiesMap.put((String) property.getKey(), propertyInfoList);

				}

			}

		}

		// Scans the Map just created for properties overridden externally (e.g. by Tomcat)

		/*

		 * for (String property : propertiesMap.keySet()) { List<PropertyInfo> propertyInfoList = propertiesMap.get(property); boolean

		 * isOverridden = true; for (PropertyInfo propInfo : propertyInfoList) { // Checks for a checker if (propInfo.isChecked) {

		 * isOverridden = false; } }

		 * 

		 * // If none of the pairs has been checked, then the property has been overridden externally. if (isOverridden &&

		 * propertyFetcherProps.getProperty(property) != null) { // Adds the current property value (which is the override) as the current

		 * one. propertyInfoList.add(new PropertyInfo(propertyFetcherProps.getProperty(property), "Overridden externally", true));

		 * propertiesMap.put(property, propertyInfoList); } }

		 */

		return propertiesMap;

	}

	/**

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

	 *

	 * @param property

	 *            The property key

	 * @param value

	 *            The property value

	 * @return true/false

	 */

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

		final String winningPropertyValue = this.propertyFetcherProps.getProperty(property);

		return value.equals(winningPropertyValue);

	}

	private class PropertyInfo {

		String value;

		String sourcePropertyFile;

		Boolean isChecked;

		public PropertyInfo(final String value, final String sourcePropertyFile, final Boolean isChecked) {

			this.value = value;

			this.sourcePropertyFile = sourcePropertyFile;

			this.isChecked = isChecked;

		}

		public String getValue() {

			return this.value;

		}

		public String getSourcePropertyFile() {

			return this.sourcePropertyFile;

		}

		public Boolean getIsChecked() {

			return this.isChecked;

		}

	}

}

package eu.dnetlib.functionality.modular.ui;

import java.io.IOException;

import java.util.Enumeration;

import java.util.List;

import javax.annotation.PostConstruct;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.log4j.Level;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Controller;

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

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

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

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

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

@Controller

public class DnetLogAjaxController extends AbstractAjaxController {

	private LogUiAppender appender;

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

	@PostConstruct

	void init() throws IOException {

		this.appender = findLogUiAppender();

	}

	private LogUiAppender findLogUiAppender() {

		final Logger logger = LogManager.getRootLogger();

		final Enumeration<?> appenders = logger.getAllAppenders();

		while (appenders.hasMoreElements()) {

			final Object app = appenders.nextElement();

			if (app instanceof LogUiAppender) {

				log.info("An istance of LogUiAppender is already registered in log4j configuration.");

				return (LogUiAppender) app;

			}

		}

		final LogUiAppender app = new LogUiAppender();

		LogManager.getRootLogger().addAppender(app);

		log.info("A new LogUiAppender has been registered in log4j configuration.");

		return app;

	}

	@RequestMapping(value = "/ui/log/tail/{n}")

	public @ResponseBody List<LogLine> tail_N(@PathVariable(value = "n") final int n) throws Exception {

		return this.appender.tail_N(n);

	}

	@RequestMapping(value = "/ui/log/continue/{after}")

	public @ResponseBody List<LogLine> tail_continue(@PathVariable(value = "after") final int after) throws Exception {

		return tail_continue(after, 0);

	}

	private List<LogLine> tail_continue(final int after, final int recursionLevel) throws Exception {

		final List<LogLine> res = this.appender.tail_continue(after);

		if (res.isEmpty() && recursionLevel < 10) {

			Thread.sleep(10000);

			return tail_continue(after, recursionLevel + 1);

		} else {

			return res;

		}

	}

	@RequestMapping(value = "/ui/log/level/{level}/{resource}")

	public @ResponseBody boolean updateLogLevel(@PathVariable(value = "level") final String level, @PathVariable(value = "resource") final String resource)

			throws Exception {

		if (resource != null && level != null) {

			LogManager.getLogger(resource).setLevel(Level.toLevel(level));

		}

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

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import com.google.gson.Gson;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

import eu.dnetlib.functionality.modular.ui.repositories.util.RepoUIUtils;

import eu.dnetlib.rmi.datasource.DatasourceManagerService;

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

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

import org.springframework.ui.ModelMap;

public class RepoApisEntryPointController extends ModuleEntryPoint {

	@Autowired

	private UniqueServiceLocator serviceLocator;

	@Autowired

	private RepoUIUtils repoUIUtils;

	private String compatibilityLevelsVocabulary;

	@Override

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

		final Gson gson = new Gson();

		map.addAttribute("compatibilityLevels", gson.toJson(this.repoUIUtils.fetchVocabularyTerms(getCompatibilityLevelsVocabulary())));

		map.addAttribute("browseFields", gson.toJson(this.serviceLocator.getService(DatasourceManagerService.class).listBrowsableFields()));

	}

	public String getCompatibilityLevelsVocabulary() {

		return this.compatibilityLevelsVocabulary;

	}

	@Required

	public void setCompatibilityLevelsVocabulary(final String compatibilityLevelsVocabulary) {

		this.compatibilityLevelsVocabulary = compatibilityLevelsVocabulary;

	}

}

package eu.dnetlib.functionality.modular.ui.repositories.controllers;

import java.util.Date;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import com.google.gson.Gson;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.AbstractAjaxController;

import eu.dnetlib.functionality.modular.ui.repositories.util.RepoUIUtils;

import eu.dnetlib.functionality.modular.ui.workflows.objects.sections.WorkflowSectionGrouper;

import eu.dnetlib.msro.workflows.procs.WorkflowExecutor;

import eu.dnetlib.rmi.data.CollectorService;

import eu.dnetlib.rmi.data.CollectorServiceException;

import eu.dnetlib.rmi.data.ProtocolParameterValue;

import eu.dnetlib.rmi.datasource.*;

import net.sf.ehcache.Cache;

import net.sf.ehcache.Element;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.stereotype.Controller;

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

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

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

@Controller

public class RepoInternalController extends AbstractAjaxController {

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

	@Autowired

	private UniqueServiceLocator serviceLocator;

	@Autowired

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Autowired

	private WorkflowExecutor workflowExecutor;

	@Autowired

	private RepoUIUtils repoUIUtils;

	@Resource(name = "repoUIJsonCache")

	private Cache repoUIJsonCache;

	@RequestMapping(value = "/ui/browseRepoField.do")

	public @ResponseBody List<BrowseTerm> browseRepoField(@RequestParam(value = "field", required = true) final String field) throws Exception {

		return this.serviceLocator.getService(DatasourceManagerService.class).browseField(field);

	}

	@SuppressWarnings("unchecked")

	@RequestMapping(value = "/ui/listApis.do")

	public @ResponseBody List<SearchInterfacesEntry> listApis(

			@RequestParam(value = "param", required = true) final String param,

			@RequestParam(value = "value", required = true) final String value,

			@RequestParam(value = "refresh", required = false) final String refresh) throws Exception {

		final String cacheKey = "list@@@" + param + "@@@" + value;

		final Element elem = this.repoUIJsonCache.get(cacheKey);

		if (elem != null && refresh == null) {

			return (List<SearchInterfacesEntry>) elem.getObjectValue();

		} else {

			log.info("Refreshing " + cacheKey + " cache...");

			final List<SearchInterfacesEntry> list = this.serviceLocator.getService(DatasourceManagerService.class).searchInterface(param, value);

			this.repoUIJsonCache.put(new Element(cacheKey, list));

			return list;

		}

	}

	@RequestMapping(value = "/ui/listRepositories.map")

	public @ResponseBody List<RepositoryMapEntry> listRepositories_asMap() throws Exception {

		return this.serviceLocator.getService(DatasourceManagerService.class).getRepositoryMap();

	}

	@RequestMapping(value = "/ui/listRepositories.json")

	public @ResponseBody List<SimpleDatasourceDesc> listRepositories(@RequestParam(value = "type", required = true) final String type) throws Exception {

		return this.serviceLocator.getService(DatasourceManagerService.class).simpleListDatasourcesByType(type);

	}

	@SuppressWarnings("unchecked")

	@RequestMapping("/ui/repo/repoApi.update")

	public @ResponseBody boolean updateRepoApi(

			@RequestParam(value = "id", required = true) final String repoId,

			@RequestParam(value = "iface", required = true) final String ifaceId,

			@RequestParam(value = "accessParams", required = true) final String accessParamsJson) throws Exception {

		if (!StringUtils.isEmpty(accessParamsJson)) {

			this.serviceLocator.getService(DatasourceManagerService.class).bulkUpdateApiAccessParams(repoId, ifaceId,

					new Gson().fromJson(accessParamsJson, Map.class));

		}

		return true;

	}

	@RequestMapping("/ui/repo/repoApiCompliance.update")

	public @ResponseBody boolean updateRepoApiCompliance(@RequestParam(value = "id", required = true) final String repoId,

			@RequestParam(value = "iface", required = true) final String ifaceId,

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

		log.debug("SET COMPLIANCE TO " + compliance);

		this.serviceLocator.getService(DatasourceManagerService.class).overrideCompliance(repoId, ifaceId, compliance);

		this.repoUIJsonCache.removeAll();

		return true;

	}

	@RequestMapping("/ui/repo/repoApiCompliance.reset")

	public @ResponseBody boolean resetRepoApiCompliance(@RequestParam(value = "id", required = true) final String repoId,

			@RequestParam(value = "iface", required = true) final String ifaceId) throws Exception {

		log.debug("RESET COMPLIANCE");

		this.serviceLocator.getService(DatasourceManagerService.class).overrideCompliance(repoId, ifaceId, null);

		this.repoUIJsonCache.removeAll();

		return true;

	}

	@RequestMapping("/ui/repoApi.new")

	public @ResponseBody boolean addRepoApi(@RequestParam(value = "repoId", required = true) final String repoId,

			@RequestParam(value = "iface", required = true) final String ifaceJson) throws DatasourceManagerServiceException {

		final IfaceDesc iface = new Gson().fromJson(ifaceJson, IfaceDesc.class);

		log.info("Adding interface " + iface.getId() + " to repository " + repoId);

		final DatasourceManagerService dsManager = this.serviceLocator.getService(DatasourceManagerService.class);

		return dsManager.addInterface(repoId, iface);

	}

	@RequestMapping("/ui/repo.new")

	public @ResponseBody boolean addRepoApi(@RequestParam(value = "repo", required = true) final String repoJson) throws DatasourceManagerServiceException {

		final DatasourceDesc ds = new Gson().fromJson(repoJson, DatasourceDesc.class);

		ds.setDateOfCollection(new Date());

		//This logic has been embedded when converting DatasourceDesc into a datasource XML profile in class eu.dnetlib.enabling.datasources.DatasourceDescToProfile

//		if (StringUtils.isBlank(ds.getEnglishName())) {

//			ds.setEnglishName(ds.getOfficialName());

//		}

		log.info("Adding datasource " + ds.getId() + " - name " + ds.getOfficialName());

		final DatasourceManagerService dsManager = this.serviceLocator.getService(DatasourceManagerService.class);

		return dsManager.addDatasource(ds);

	}

	@RequestMapping("/ui/listValidValuesForParam.do")

	public @ResponseBody List<ProtocolParameterValue> listValidValuesForParam(

			@RequestParam(value = "protocol", required = true) final String protocol,

			@RequestParam(value = "param", required = true) final String param,