D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-modular-repositories-ui/trunk/", "deploy_repository": "dnet45-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/dnet45-snapshots", "name": "dnet-modular-repositories-ui"}

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

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Set;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.dom4j.Document;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

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

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

import org.springframework.ui.ModelMap;

import com.google.common.base.Splitter;

import com.google.common.collect.Lists;

import com.google.common.collect.Sets;

import com.google.gson.Gson;

import eu.dnetlib.enabling.datasources.common.Api;

import eu.dnetlib.enabling.datasources.common.Datasource;

import eu.dnetlib.enabling.datasources.common.LocalDatasourceManager;

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

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

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

import eu.dnetlib.miscutils.collections.Pair;

public class RepoApisEntryPointController extends ModuleEntryPoint {

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource

	private RepoUIUtils repoUIUtils;

	private String compatibilityLevelsVocabulary;

	private String validatorAddress;

	private String validatorServiceAddress;

	@Autowired

	private LocalDatasourceManager<Datasource<?, ?>, Api<?>> dsManager;

	public class RepoHIWorkflow implements Comparable<RepoHIWorkflow> {

		private final String id;

		private final String name;

		private final Set<String> ifaceTypes;

		private final Set<String> compliances;

		private List<Pair<String, String>> fields;

		/**

		 * Instantiates a new repo hi workflow.

		 *

		 * @param id

		 *            the id

		 * @param name

		 *            the name

		 * @param ifaceTypes

		 *            the iface types

		 * @param compliances

		 *            the compliances

		 * @param fields

		 *            the fields

		 */

		public RepoHIWorkflow(final String id, final String name, final Set<String> ifaceTypes, final Set<String> compliances,

				final List<Pair<String, String>> fields) {

			super();

			this.id = id;

			this.name = name;

			this.ifaceTypes = ifaceTypes;

			this.compliances = compliances;

			this.fields = fields;

		}

		public String getId() {

			return id;

		}

		public String getName() {

			return name;

		}

		public Set<String> getIfaceTypes() {

			return ifaceTypes;

		}

		public Set<String> getCompliances() {

			return compliances;

		}

		@Override

		public int compareTo(final RepoHIWorkflow o) {

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

		}

		/**

		 * @return the fields

		 */

		public List<Pair<String, String>> getFields() {

			return fields;

		}

		/**

		 * @param fields

		 *            the fields to set

		 */

		public void setFields(final List<Pair<String, String>> fields) {

			this.fields = fields;

		}

	}

	private RepoHIWorkflow parseQuery(final String input) {

		final SAXReader reader = new SAXReader();

		try {

			final Document doc = reader.read(new StringReader(input));

			final String id = doc.valueOf("//id");

			final String name = doc.valueOf("//name");

			final String type = doc.valueOf("//types");

			final String compliance = doc.valueOf("//compliances");

			final Set<String> ifcTypes = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().trimResults().split(type));

			final Set<String> compliances = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().trimResults().split(compliance));

			final List<Pair<String, String>> fields = new ArrayList<>();

			for (final Object o : doc.selectNodes(".//FIELD")) {

				final Node currentNode = (Node) o;

				final String key = currentNode.valueOf("@name");

				final String value = currentNode.getText();

				fields.add(new Pair<>(key, value));

			}

			return new RepoHIWorkflow(id, name, ifcTypes, compliances, fields);

		} catch (final Exception e) {

			return null;

		}

	}

	private List<RepoHIWorkflow> listRepoHIWorkflows() throws ISLookUpException {

		final String xquery =

				"for $x in collection('/db/DRIVER/WorkflowDSResources/WorkflowDSResourceType') where $x//WORKFLOW_TYPE='REPO_HI' return <result> <id>{$x//RESOURCE_IDENTIFIER/@value/string()}</id> <name>{$x//WORKFLOW_NAME/text()}</name> <types>{$x//PARAM[@name='expectedInterfaceTypologyPrefixes']/text()}</types> <compliances>{$x//PARAM[@name='expectedCompliancePrefixes']/text()}</compliances> {$x//FIELD} </result>";

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

		for (final String s : serviceLocator.getService(ISLookUpService.class).quickSearchProfile(xquery)) {

			final RepoHIWorkflow repoHiInfo = parseQuery(s);

			if (repoHiInfo != null) {

				list.add(repoHiInfo);

			}

		}

		Collections.sort(list);

		return list;

	}

	@Override

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

		final Gson gson = new Gson();

		map.addAttribute("availableRepohiWfs", gson.toJson(listRepoHIWorkflows()));

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

		map.addAttribute("browseFields", gson.toJson(dsManager.listBrowsableFields()));

		map.addAttribute("validatorAddress", getValidatorAddress());

		map.addAttribute("validatorServiceAddress", getValidatorServiceAddress());

	}

	public String getCompatibilityLevelsVocabulary() {

		return compatibilityLevelsVocabulary;

	}

	@Required

	public void setCompatibilityLevelsVocabulary(final String compatibilityLevelsVocabulary) {

		this.compatibilityLevelsVocabulary = compatibilityLevelsVocabulary;

	}

	public String getValidatorAddress() {

		return validatorAddress;

	}

	@Required

	public void setValidatorAddress(final String validatorAddress) {

		this.validatorAddress = validatorAddress;

	}

	public String getValidatorServiceAddress() {

		return validatorServiceAddress;

	}

	@Required

	public void setValidatorServiceAddress(final String validatorServiceAddress) {

		this.validatorServiceAddress = validatorServiceAddress;

	}

}

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

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

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

@Deprecated

public class RepositoriesGoogleMapEntryPointController extends ModuleEntryPoint {

	@Override

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

}

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

import java.io.StringReader;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.Resource;

import org.antlr.stringtemplate.StringTemplate;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang.StringEscapeUtils;

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

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

import org.springframework.core.io.ClassPathResource;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Sets;

import eu.dnetlib.data.collector.rmi.CollectorService;

import eu.dnetlib.data.collector.rmi.ProtocolDescriptor;

import eu.dnetlib.data.collector.rmi.ProtocolParameter;

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

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.repositories.objects.RepoInterfaceEntry;

import eu.dnetlib.functionality.modular.ui.repositories.objects.RepoMetaWfEntry;

import eu.dnetlib.functionality.modular.ui.repositories.objects.SimpleParamEntry;

import eu.dnetlib.functionality.modular.ui.repositories.objects.VocabularyEntry;

import eu.dnetlib.msro.workflows.util.WorkflowsConstants.WorkflowStatus;

public class RepoUIUtils {

	@Resource

	private UniqueServiceLocator serviceLocator;

	private final ClassPathResource getRepoApiQueryTmpl =

			new ClassPathResource("/eu/dnetlib/functionality/modular/ui/repositories/templates/getRepoApi.xquery.st");

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

	private final Map<String, List<ProtocolParameter>> parametersMap = Maps.newHashMap();

	public RepoInterfaceEntry getApi(final String repoId, final String ifaceId) throws Exception {

		final RepoInterfaceEntry ifc = new RepoInterfaceEntry();

		final StringTemplate st = new StringTemplate(IOUtils.toString(getRepoApiQueryTmpl.getInputStream()));

		st.setAttribute("dsId", repoId);

		st.setAttribute("ifaceId", ifaceId);

		final String query = st.toString();

		final SAXReader reader = new SAXReader();

		final String s = serviceLocator.getService(ISLookUpService.class).getResourceProfileByQuery(query);

		final Document doc = reader.read(new StringReader(s));

		ifc.setId(doc.valueOf("/api/id"));

		ifc.setLabel(doc.valueOf("/api/label"));

		ifc.setRemovable(doc.valueOf("/api/removable").equalsIgnoreCase("true") && doc.selectNodes("//metaWF").isEmpty());

		ifc.setRepoId(doc.valueOf("/api/repo/@id"));

		ifc.setRepoName(StringEscapeUtils.unescapeHtml(doc.valueOf("/api/repo")));

		ifc.setRepoCountry(doc.valueOf("/api/repo/@country"));

		ifc.setRepoPrefix(doc.valueOf("/api/repo/@prefix"));

		ifc.setRepoType(doc.valueOf("/api/repo/@type"));

		ifc.setEmail(doc.valueOf("/api/repo/@email"));

		final String protocol = doc.valueOf("/api/protocol");

		ifc.setProtocol(protocol);

		final Set<String> toVerifyParams = getParameterNamesForProtocol(ifc.getProtocol());

		for (final Object o : doc.selectNodes("/api/commonParams/param")) {

			final Node n = (Node) o;

			ifc.getCommonParams().add(new SimpleParamEntry(n.valueOf("@name"), n.getText()));

		}

		log.debug("****** " + toVerifyParams);

		for (final Object o : doc.selectNodes("/api/accessParams/param")) {

			final Node n = (Node) o;

			final String pname = n.valueOf("@name");

			if (toVerifyParams.contains(pname)) {

				ifc.getAccessParams().add(new SimpleParamEntry(pname, n.getText()));

				toVerifyParams.remove(pname);

			} else {

				log.warn("Invalid param [" + pname + "] for protocol " + protocol + " in repo " + repoId);

			}

		}

		for (final String pname : toVerifyParams) {

			ifc.getAccessParams().add(new SimpleParamEntry(pname, ""));

			log.info("Adding missing param [" + pname + "] for protocol " + protocol + " in repo " + repoId);

		}

		for (final Object o : doc.selectNodes("/api/extraFields/field")) {

			final Node n = (Node) o;

			final String name = n.valueOf("@name");

			final String value = n.getText();

			if (name.equalsIgnoreCase("overriding_compliance")) {

				for (final SimpleParamEntry e : ifc.getCommonParams()) {

					if (e.getName().equals("compliance")) {

						// The original compliance (assigned by the validator) is stored in otherValue

						e.setOtherValue(value);

					}

				}

			} else if (name.equalsIgnoreCase("last_aggregation_date")) {

				ifc.setAggrDate(value);

			} else if (name.equalsIgnoreCase("last_aggregation_total")) {

				ifc.setAggrTotal(NumberUtils.toInt(value, 0));

			} else if (name.equalsIgnoreCase("last_aggregation_mdId")) {

				ifc.setAggrMdId(value);

			} else if (name.equalsIgnoreCase("last_collection_date")) {

				ifc.setCollDate(value);

			} else if (name.equalsIgnoreCase("last_collection_total")) {

				ifc.setCollTotal(NumberUtils.toInt(value, 0));

			} else if (name.equalsIgnoreCase("last_collection_mdId")) {

				ifc.setCollMdId(value);

			} else if (name.equalsIgnoreCase("last_download_date")) {

				ifc.setDownloadDate(value);

			} else if (name.equalsIgnoreCase("last_download_total")) {

				ifc.setDownloadTotal(NumberUtils.toInt(value, 0));

			} else if (name.equalsIgnoreCase("last_download_objId")) {

				ifc.setDownloadObjId(value);

			} else {

				ifc.getOtherParams().add(new SimpleParamEntry(name, value));

			}

		}

		if (doc.selectNodes("/api/extraFields/field[@name='metadata_identifier_path']").isEmpty()) {

			ifc.getOtherParams().add(new SimpleParamEntry("metadata_identifier_path", ""));

		}

		for (final Object o : doc.selectNodes("//metaWF")) {

			final Node n = (Node) o;

			final String id = n.valueOf("./id");

			final String name = n.valueOf("./name");

			final String status = n.valueOf("./status");

			final String repoByeWfId = n.valueOf("./destroyWorkflow");

			int progress = 0;

			try {

				switch (WorkflowStatus.valueOf(status)) {

				case MISSING:

					progress = 0;

					break;

				case ASSIGNED:

					progress = 25;

					break;

				case WAIT_SYS_SETTINGS:

					progress = 50;

					break;

				case WAIT_USER_SETTINGS:

					progress = 75;

					break;

				case EXECUTABLE:

					progress = 100;

					break;

				}

			} catch (final Exception e) {

				progress = 0;

			}

			ifc.getMetaWFs().add(new RepoMetaWfEntry(id, name, status, repoByeWfId, progress));

		}

		return ifc;

	}

	public List<VocabularyEntry> fetchVocabularyTerms(final String voc) throws ISLookUpException {

		final String xquery = "for $x in collection('/db/DRIVER/VocabularyDSResources/VocabularyDSResourceType')[.//VOCABULARY_NAME/@code = '"

				+ voc.trim() + "']//TERM return concat($x/@code, ' @@@ ', $x/@english_name)";

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

		for (final String s : serviceLocator.getService(ISLookUpService.class).quickSearchProfile(xquery)) {

			final String[] arr = s.split("@@@");

			list.add(new VocabularyEntry(arr[0].trim(), arr[1].trim()));

		}

		Collections.sort(list);

		return list;

	}

	private Set<String> getParameterNamesForProtocol(final String protocol) {

		if (parametersMap.isEmpty()) {

			for (final ProtocolDescriptor d : serviceLocator.getService(CollectorService.class).listProtocols()) {

				parametersMap.put(d.getName().toLowerCase(), d.getParams());

			}

		}

		final Set<String> res = Sets.newHashSet();

		if (parametersMap.containsKey(protocol.toLowerCase())) {

			res.add("baseUrl");

			for (final ProtocolParameter p : parametersMap.get(protocol.toLowerCase())) {

				res.add(p.getName());

			}

		}

		return res;

	}

}

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

import java.io.StringReader;

import java.util.Date;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang.StringUtils;

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

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.http.HttpStatus;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

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

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

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

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

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

import com.google.common.collect.Maps;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

import eu.dnetlib.data.collector.rmi.CollectorService;

import eu.dnetlib.data.collector.rmi.CollectorServiceException;

import eu.dnetlib.data.collector.rmi.ProtocolParameterValue;

import eu.dnetlib.enabling.datasources.common.Api;

import eu.dnetlib.enabling.datasources.common.ApiParam;

import eu.dnetlib.enabling.datasources.common.ApiParamImpl;

import eu.dnetlib.enabling.datasources.common.BrowseTerm;

import eu.dnetlib.enabling.datasources.common.Datasource;

import eu.dnetlib.enabling.datasources.common.DsmException;

import eu.dnetlib.enabling.datasources.common.Identity;

import eu.dnetlib.enabling.datasources.common.LocalDatasourceManager;

import eu.dnetlib.enabling.datasources.common.Organization;

import eu.dnetlib.enabling.datasources.common.SearchApisEntry;

import eu.dnetlib.enabling.datasources.common.SimpleDatasource;

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

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

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

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

import eu.dnetlib.functionality.modular.ui.repositories.objects.RepoInterfaceEntry;

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

import eu.dnetlib.miscutils.functional.xml.ApplyXslt;

import eu.dnetlib.msro.workflows.sarasvati.loader.WorkflowExecutor;

import eu.dnetlib.msro.workflows.util.WorkflowsConstants;

@Controller

public class RepoInternalController {

	@Autowired

	private LocalDatasourceManager<Datasource<?, ?>, Api<?>> dsManager;

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Resource

	private WorkflowExecutor workflowExecutor;

	@Resource

	private RepoUIUtils repoUIUtils;

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

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

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

		return dsManager.browseField(field);

	}

	@Cacheable(cacheNames = "repoUIJsonCache", key = "#param, #value", condition = "#refresh == false")

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

	public @ResponseBody List<? extends SearchApisEntry> 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 {

		return dsManager.searchApis(param, value);

	}

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

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

		return dsManager.searchDatasourcesByType(type);

	}

	@CacheEvict("repoUIJsonCache")

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

	public @ResponseBody String listRepositories(@RequestParam(value = "id", required = true) final String id,

			@RequestParam(value = "b", required = true) final boolean b) throws Exception {

		final String query = "count(/*[.//RESOURCE_TYPE/@value='MetaWorkflowDSResourceType' and .//DATAPROVIDER/@id='" + id + "'])";

		if (!b && Integer.parseInt(serviceLocator.getService(ISLookUpService.class).getResourceProfileByQuery(query)) > 0) { throw new Exception("Repo " + id

				+ " can be invalidated: it is related to some metawfs"); }

		final String newId = b ? serviceLocator.getService(ISRegistryService.class).validateProfile(id)

				: serviceLocator.getService(ISRegistryService.class).invalidateProfile(id);

		return newId;

	}

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

	public void getRepoDetails(final HttpServletResponse response, @RequestParam(value = "id", required = true) final String id) throws Exception {

		String profile;

		try {

			profile = serviceLocator.getService(ISLookUpService.class).getResourceProfile(id);

		} catch (final ISLookUpDocumentNotFoundException e) {

			profile = serviceLocator.getService(ISLookUpService.class).getResourceProfileByQuery(

					"collection('/db/DRIVER/RepositoryServiceResources/RepositoryServiceResourceType')/*[.//DATASOURCE_ORIGINAL_ID='" + id + "']");

		}

		final ApplyXslt xslt = new ApplyXslt(IOUtils.toString(getClass().getResourceAsStream(

				"/eu/dnetlib/functionality/modular/ui/repositories/xslt/repoDetails.xslt")));

		IOUtils.copy(new StringReader(xslt.evaluate(profile)), response.getOutputStream());

	}

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

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

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

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

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

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

		params.put(WorkflowsConstants.DATAPROVIDER_ID, repoId);

		params.put(WorkflowsConstants.DATAPROVIDER_NAME, repoName);

		params.put(WorkflowsConstants.DATAPROVIDER_INTERFACE, ifaceId);

		return workflowExecutor.startProcess(wfId, params);

	}

	@RequestMapping("/ui/repoMetaWf.destroy")

	public @ResponseBody String destroyDataProviderWorkflow(@RequestParam(value = "destroyWf", required = true) final String destroyWfId)

			throws Exception {

		return workflowExecutor.startProcess(destroyWfId, null);

	}

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

	public @ResponseBody RepoInterfaceEntry getRepoApi(@RequestParam(value = "repoId", required = true) final String repoId,

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

		return repoUIUtils.getApi(repoId, ifaceId);

	}

	@RequestMapping("/ui/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 = false) final String accessParamsJson,

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

		if (!StringUtils.isEmpty(accessParamsJson)) {

			final Map<String, String> params = new Gson().fromJson(accessParamsJson, new TypeToken<Map<String, String>>() {}.getType());

			final String baseUrl = params.remove("baseUrl");

			dsManager.updateApiDetails(repoId, ifaceId, mdIdPath, baseUrl, params);

		}

		return true;

	}

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

	public @ResponseBody boolean updateRepoApi(

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

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

		dsManager.deleteApi(repoId, ifaceId);

		return true;

	}

	@CacheEvict("repoUIJsonCache")

	@RequestMapping("/ui/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);

		dsManager.updateCompliance(repoId, ifaceId, compliance, true);

		return true;

	}

	@CacheEvict("repoUIJsonCache")

	@RequestMapping("/ui/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");

		dsManager.updateCompliance(repoId, ifaceId, null, true);

		return true;

	}

	@RequestMapping("/ui/repos/repoApi.html")

	public void resetRepoApiCompliance(final ModelMap map) throws Exception {}

	@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 DsmException {

		final Api<ApiParam> iface = new Gson().fromJson(ifaceJson, new TypeToken<Api<ApiParamImpl>>() {}.getType());

		iface.setDatasource(repoId);

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

		dsManager.addApi(iface);

		return true;

	}

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

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

		final Datasource<Organization<?>, Identity> ds = new Gson().fromJson(repoJson, new TypeToken<Datasource<Organization<?>, Identity>>() {}.getType());

		final Date now = new Date();

		ds.setDateofcollection(new java.sql.Date(now.getTime()));

		if (StringUtils.isBlank(ds.getEnglishname())) {

			ds.setEnglishname(ds.getOfficialname());

		}

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

		dsManager.saveDs(ds);

		return true;

	}

	@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,

			@RequestParam(value = "baseUrl", required = true) final String baseUrl) throws CollectorServiceException {

		return serviceLocator.getService(CollectorService.class).listValidValuesForParam(protocol, baseUrl, param, null);

	}

	@ExceptionHandler(Exception.class)

	@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)

	public @ResponseBody ErrorMessage handleException(final HttpServletRequest req, final Exception e) {

		log.error("Error processing " + req.getRequestURI(), e);

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

	}

}

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

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

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

import org.springframework.ui.ModelMap;

import com.google.common.base.Function;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.gson.Gson;

import eu.dnetlib.data.collector.rmi.CollectorService;

import eu.dnetlib.data.collector.rmi.ProtocolDescriptor;

import eu.dnetlib.data.collector.rmi.ProtocolParameter;

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

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

import eu.dnetlib.functionality.modular.ui.repositories.objects.VocabularyEntry;

public class AddRepoApiEntryPointController extends ModuleEntryPoint {

	private String datasourceTypeVocabulary;

	private String complianceVocabulary;

	private String contentDescriptionsVocabulary;

	private String protocolsVocabulary;

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource

	private RepoUIUtils repoUIUtils;

	@Override

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

		final Gson gson = new Gson();

		map.addAttribute("types", gson.toJson(repoUIUtils.fetchVocabularyTerms(datasourceTypeVocabulary)));

		map.addAttribute("compliances", gson.toJson(repoUIUtils.fetchVocabularyTerms(complianceVocabulary)));

		map.addAttribute("contentDescriptions", gson.toJson(repoUIUtils.fetchVocabularyTerms(contentDescriptionsVocabulary)));

		map.addAttribute("protocols", gson.toJson(listProtocols()));

	}

	private List<ProtocolDescriptor> listProtocols() throws ISLookUpException {

		final Map<String, List<ProtocolParameter>> mapParams = Maps.newHashMap();

		for (ProtocolDescriptor pd : serviceLocator.getService(CollectorService.class).listProtocols()) {

			mapParams.put(pd.getName().trim().toLowerCase(), pd.getParams());

		}

		return Lists.transform(repoUIUtils.fetchVocabularyTerms(protocolsVocabulary), new Function<VocabularyEntry, ProtocolDescriptor>() {

			@Override

			public ProtocolDescriptor apply(final VocabularyEntry e) {

				final ProtocolDescriptor pd = new ProtocolDescriptor();

				pd.setName(e.getName());

				if (mapParams.containsKey(e.getName().toLowerCase().trim())) {

					pd.setParams(mapParams.get(e.getName().toLowerCase().trim()));

				} else {

					pd.setParams(new ArrayList<ProtocolParameter>());

				}

				return pd;

			}

		});

	}

	public String getDatasourceTypeVocabulary() {

		return datasourceTypeVocabulary;

	}

	@Required

	public void setDatasourceTypeVocabulary(final String datasourceTypeVocabulary) {

		this.datasourceTypeVocabulary = datasourceTypeVocabulary;

	}

	public String getComplianceVocabulary() {

		return complianceVocabulary;

	}

	@Required

	public void setComplianceVocabulary(final String complianceVocabulary) {

		this.complianceVocabulary = complianceVocabulary;

	}

	public String getContentDescriptionsVocabulary() {

		return contentDescriptionsVocabulary;

	}

	@Required

	public void setContentDescriptionsVocabulary(final String contentDescriptionsVocabulary) {

		this.contentDescriptionsVocabulary = contentDescriptionsVocabulary;

	}

	public String getProtocolsVocabulary() {

		return protocolsVocabulary;

	}

	@Required

	public void setProtocolsVocabulary(final String protocolsVocabulary) {

		this.protocolsVocabulary = protocolsVocabulary;

	}

}

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

import java.util.ArrayList;

import java.util.List;

import eu.dnetlib.enabling.datasources.common.SearchApisEntry;

public class RepoInterfaceEntry extends SearchApisEntry {

	private String label;

	private boolean removable = false;

	private String collDate = "";

	private int collTotal = 0;

	private String collMdId = "";

	private String aggrMdId = "";

	private String downloadDate = "";

	private int downloadTotal = 0;

	private String downloadObjId = "";

	private String repoType;

	private String email;

	private List<SimpleParamEntry> commonParams = new ArrayList<>();

	private List<SimpleParamEntry> accessParams = new ArrayList<>();

	private List<SimpleParamEntry> otherParams = new ArrayList<>();

	private List<RepoMetaWfEntry> metaWFs = new ArrayList<>();

	public String getLabel() {

		return label;

	}

	public void setLabel(final String label) {

		this.label = label;

	}

	public String getCollDate() {

		return collDate;

	}

	public void setCollDate(final String collDate) {

		this.collDate = collDate;

	}

	public int getCollTotal() {

		return collTotal;

	}

	public void setCollTotal(final int collTotal) {

		this.collTotal = collTotal;

	}

	public List<SimpleParamEntry> getCommonParams() {

		return commonParams;

	}

	public void setCommonParams(final List<SimpleParamEntry> commonParams) {

		this.commonParams = commonParams;

	}

	public List<SimpleParamEntry> getAccessParams() {

		return accessParams;

	}

	public void setAccessParams(final List<SimpleParamEntry> accessParams) {

		this.accessParams = accessParams;

	}

	public List<SimpleParamEntry> getOtherParams() {

		return otherParams;

	}

	public void setOtherParams(final List<SimpleParamEntry> otherParams) {

		this.otherParams = otherParams;

	}

	public List<RepoMetaWfEntry> getMetaWFs() {

		return metaWFs;

	}

	public void setMetaWFs(final List<RepoMetaWfEntry> metaWFs) {

		this.metaWFs = metaWFs;

	}

	public String getAggrMdId() {

		return aggrMdId;

	}

	public void setAggrMdId(final String aggrMdId) {

		this.aggrMdId = aggrMdId;

	}

	public String getCollMdId() {

		return collMdId;

	}

	public void setCollMdId(final String collMdId) {

		this.collMdId = collMdId;

	}

	public String getDownloadDate() {

		return downloadDate;

	}

	public void setDownloadDate(final String downloadDate) {

		this.downloadDate = downloadDate;

	}

	public int getDownloadTotal() {

		return downloadTotal;

	}

	public void setDownloadTotal(final int downloadTotal) {

		this.downloadTotal = downloadTotal;

	}

	public String getDownloadObjId() {

		return downloadObjId;

	}

	public void setDownloadObjId(final String downloadObjId) {

		this.downloadObjId = downloadObjId;

	}

	public String getRepoType() {

		return repoType;

	}

	public void setRepoType(final String repoType) {

		this.repoType = repoType;

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(final String email) {

		this.email = email;

	}

	public boolean isRemovable() {

		return removable;

	}

	public void setRemovable(final boolean removable) {

		this.removable = removable;

	}

}

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

public class VocabularyEntry implements Comparable<VocabularyEntry> {

	private String name;

	private String desc;

	public VocabularyEntry() {}

	public VocabularyEntry(final String name, final String desc) {

		this.name = name;

		this.desc = desc;

	}

	public String getName() {

		return name;

	}

	public void setName(final String name) {

		this.name = name;

	}

	public String getDesc() {

		return desc;

	}

	public void setDesc(final String desc) {

		this.desc = desc;

	}

	@Override

	public int compareTo(final VocabularyEntry o) {

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

	}

}

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

public class RepoMetaWfEntry implements Comparable<RepoMetaWfEntry> {

	private String id;

	private String name;

	private String status;

	private String destroyWorkflow;

	private int progress;

	public RepoMetaWfEntry(final String id, final String name, final String status, final String destroyWorkflow, final int progress) {

		this.id = id;

		this.name = name;

		this.status = status;

		this.destroyWorkflow = destroyWorkflow;

		this.progress = progress;

	}

	@Override

	public int compareTo(final RepoMetaWfEntry o) {

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

	}

	public String getId() {

		return id;

	}

	public String getName() {

		return name;

	}

	public String getStatus() {

		return status;

	}

	public String getDestroyWorkflow() {

		return destroyWorkflow;

	}

	public int getProgress() {

		return progress;

	}

}

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

public class SimpleParamEntry implements Comparable<SimpleParamEntry> {

	private String id;

	private String name;

	private Object value;

	private Object otherValue;

	public SimpleParamEntry(final String name, final Object value) {

		this(name, name, value, null);

	}

	public SimpleParamEntry(final String id, final String name, final Object value) {

		this(id, name, value, null);

	}

	public SimpleParamEntry(final String id, final String name, final Object value, final Object otherValue) {

		this.id = id;

		this.name = name;

		this.value = value;

		this.setOtherValue(otherValue);

	}

	public String getId() {

		return id;

	}

	public void setId(final String id) {

		this.id = id;

	}

	public Object getValue() {

		return value;

	}

	public void setValue(final Object value) {

		this.value = value;

	}

	public String getName() {

		return name;

	}

	public void setName(final String name) {

		this.name = name;

	}

	public Object getOtherValue() {

		return otherValue;

	}

	public void setOtherValue(Object otherValue) {

		this.otherValue = otherValue;

	}

	@Override

	public int compareTo(final SimpleParamEntry o) {

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

	}

}

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

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

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

import org.springframework.ui.ModelMap;

import com.google.gson.Gson;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

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

public class AddRepoEntryPointController extends ModuleEntryPoint {

	private String datasourceTypeVocabulary;

	private String datasourceCountryVocabulary;

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Resource

	private RepoUIUtils repoUIUtils;

	@Override

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

		final Gson gson = new Gson();

		map.addAttribute("types", gson.toJson(repoUIUtils.fetchVocabularyTerms(datasourceTypeVocabulary)));

		map.addAttribute("countries", gson.toJson(repoUIUtils.fetchVocabularyTerms(datasourceCountryVocabulary)));

	}

	public String getDatasourceTypeVocabulary() {

		return datasourceTypeVocabulary;

	}

	@Required

	public void setDatasourceTypeVocabulary(final String datasourceTypeVocabulary) {

		this.datasourceTypeVocabulary = datasourceTypeVocabulary;

	}

	public String getDatasourceCountryVocabulary() {

		return datasourceCountryVocabulary;

	}

	@Required

	public void setDatasourceCountryVocabulary(final String datasourceCountryVocabulary) {

		this.datasourceCountryVocabulary = datasourceCountryVocabulary;

	}

}

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

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

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

import org.springframework.ui.ModelMap;

import com.google.gson.Gson;

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

public class RepoEnablerEntryPointController extends ModuleEntryPoint {

	private String datasourceTypeVocabulary;

	@Resource

	private RepoUIUtils repoUIUtils;

	@Override

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

		map.addAttribute("types", new Gson().toJson(repoUIUtils.fetchVocabularyTerms(getDatasourceTypeVocabulary())));

	}

	public String getDatasourceTypeVocabulary() {

		return datasourceTypeVocabulary;

	}

	@Required

	public void setDatasourceTypeVocabulary(final String datasourceTypeVocabulary) {

		this.datasourceTypeVocabulary = datasourceTypeVocabulary;

	}

}

<RESOURCE_PROFILE xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

	<HEADER>

		<RESOURCE_IDENTIFIER value="1f3dacf7-2cbb-4b88-9afd-43a3fbd03042_Vm9jYWJ1bGFyeURTUmVzb3VyY2VzL1ZvY2FidWxhcnlEU1Jlc291cmNlVHlwZQ==" />

		<RESOURCE_TYPE value="VocabularyDSResourceType" />

		<RESOURCE_KIND value="VocabularyDSResources" />

		<RESOURCE_URI value="String" />

		<DATE_OF_CREATION value="2014-07-10T12:24:17+02:00" />

	</HEADER>

	<BODY>

		<CONFIGURATION>

			<VOCABULARY_NAME code="ModularUiLabels">ModularUiLabels</VOCABULARY_NAME>

			<VOCABULARY_DESCRIPTION>Labels used by the Modular UI</VOCABULARY_DESCRIPTION>

			<TERMS>

				<TERM native_name="Pending datasource" code="PendingRepositoryResources" english_name="Pending datasource" encoding="DNET">

					<SYNONYMS />

					<RELATIONS />

				</TERM>

				<TERM native_name="Valid datasource" code="RepositoryServiceResources" english_name="Valid datasource" encoding="DNET">

					<SYNONYMS />

					<RELATIONS />

				</TERM>

			</TERMS>

		</CONFIGURATION>

		<STATUS>

			<LAST_UPDATE value="2014-07-10T12:24:16+02:00" />

		</STATUS>

		<SECURITY_PARAMETERS />

	</BODY>

</RESOURCE_PROFILE>

<?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 name="/ui/repoApis.do"

		class="eu.dnetlib.functionality.modular.ui.repositories.RepoApisEntryPointController"

		p:menu="Overview" p:title="DataSource API Management"

		p:description="DataSource API configuration page" p:group="DataSource Management"

		p:order="5"

		p:groupOrder="10"

		p:compatibilityLevelsVocabulary="${repo.ui.compatibilityLevels.vocabulary}"

		p:validatorAddress="${repo.ui.validator.address}"

		p:validatorServiceAddress="${repo.ui.validatorService.address}">

		<property name="permissionLevels">

			<set>

				<value>DS_ADMIN</value>

			</set>

		</property>

	</bean>

	<bean name="/ui/addRepo.do"

		class="eu.dnetlib.functionality.modular.ui.repositories.AddRepoEntryPointController"

		p:menu="Add new Datasource" p:title="Create a new Datasource"

		p:description="Create a new dataSource" p:group="DataSource Management"

		p:order="6"

		p:groupOrder="10"

		p:datasourceTypeVocabulary="${repo.ui.datasourceTypes.vocabulary}"

		p:datasourceCountryVocabulary="${repo.ui.datasourceCountries.vocabulary}"

		p:validMenuEntry="${repo.ui.addRepo.show}">

		<property name="permissionLevels">

			<set>

				<value>DS_ADMIN</value>

			</set>

		</property>

	</bean>

	<bean name="/ui/addRepoApi.do"

		class="eu.dnetlib.functionality.modular.ui.repositories.AddRepoApiEntryPointController"

		p:menu="Add new API" p:title="Create a new API"

		p:description="Create a new dataSource API" p:group="DataSource Management"

		p:order="7"

		p:groupOrder="10"

		p:datasourceTypeVocabulary="${repo.ui.datasourceTypes.vocabulary}"

		p:complianceVocabulary="${repo.ui.compatibilityLevels.vocabulary}"

		p:contentDescriptionsVocabulary="${repo.ui.contentDescriptions.vocabulary}"

		p:protocolsVocabulary="${repo.ui.protocols.vocabulary}"

		p:validMenuEntry="${repo.ui.addApi.show}">

		<property name="permissionLevels">

			<set>

				<value>DS_ADMIN</value>

			</set>

		</property>

	</bean>

	<bean name="/ui/repos.do"

		class="eu.dnetlib.functionality.modular.ui.repositories.RepoEnablerEntryPointController"

		p:menu="DataSource Enabler" p:title="DataSource Enabler"

		p:description="DataSource Enabler" p:group="DataSource Management"

		p:order="8"

		p:groupOrder="10"

		p:datasourceTypeVocabulary="${repo.ui.datasourceTypes.vocabulary}"

		p:validMenuEntry="${repo.ui.validation.show}">

		<property name="permissionLevels">

			<set>

				<value>DS_ADMIN</value>

			</set>

		</property>

	</bean>

	<!--<bean name="/ui/reposMap.do"-->

		<!--class="eu.dnetlib.functionality.modular.ui.repositories.RepositoriesGoogleMapEntryPointController"-->

		<!--p:menu="DataSource Map" p:title="Datasource Map"-->

		<!--p:description="The map of the managed datasources" p:group="DataSource Management"-->

		<!--p:order="10"-->

		<!--p:groupOrder="10">-->

		<!--<property name="permissionLevels">-->

			<!--<set>-->

				<!--<value>USER</value>-->

				<!--<value>DS_ADMIN</value>-->

			<!--</set>-->

		<!--</property>-->

	<!--</bean>-->

</beans>

repo.ui.compatibilityLevels.vocabulary 	= dnet:compatibilityLevel

repo.ui.datasourceTypes.vocabulary		= dnet:datasource_typologies

repo.ui.contentDescriptions.vocabulary 	= dnet:content_description_typologies

repo.ui.protocols.vocabulary 			= dnet:protocols

repo.ui.datasourceCountries.vocabulary  = dnet:countries

repo.ui.validation.show 				= false

repo.ui.addApi.show 					= true

repo.ui.addRepo.show 					= true

repo.ui.validator.address               = http://dev.openaire.research-infrastructures.eu:8880/validator

repo.ui.validatorService.address        = http://dev.openaire.research-infrastructures.eu:8880/validator-service

<?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 name="repoUIUtils" class="eu.dnetlib.functionality.modular.ui.repositories.RepoUIUtils" />

</beans>

<?xml version="1.0"?>

<xsl:stylesheet version="1.0"

	xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

	<xsl:output omit-xml-declaration="yes" method="html" />

	<xsl:template match="/">

		<div>

			<div class="well">

				<fieldset>

					<legend><h4>General</h4></legend>

					<table class="table table-bordered table-striped">

						<tbody>

							<tr>

								<td width="25%">Name</td>

								<td><xsl:value-of select=".//OFFICIAL_NAME" /></td>

							</tr><tr>

								<td width="25%">Typology</td>

								<td><xsl:value-of select=".//DATASOURCE_TYPE" /></td>

							</tr><tr>

								<td width="25%">Level of compliance</td>

								<td><xsl:value-of select=".//DATASOURCE_COMPLIANCE_DEGREE" /></td>

							</tr><tr>

								<td width="25%">Country</td>

								<td><xsl:value-of select=".//COUNTRY" /></td>

							</tr><tr>

								<td width="25%">Institution</td>

								<td><a href="{.//REPOSITORY_WEBPAGE}"><xsl:value-of select=".//REPOSITORY_INSTITUTION" /></a></td>

							</tr><tr>

								<td width="25%">Contact email</td>

								<td><a href="mailto:{.//ADMIN_INFO}"><xsl:value-of select=".//ADMIN_INFO" /></a></td>

							</tr>

						</tbody>

					</table>

				</fieldset>

			</div>

			<div class="well">

				<fieldset>

					<legend><h4>Status</h4></legend>

					<table class="table table-bordered table-striped">

						<tbody>

							<tr>

								<td width="25%">Size</td>

								<td><xsl:value-of select=".//NUMBER_OF_OBJECTS" /></td>

							</tr><tr>

								<td width="25%">Last update</td>

								<td><xsl:value-of select=".//LAST_UPDATE" /></td>

							</tr><tr>

								<td width="25%">Registered By</td>

								<td><xsl:value-of select=".//REGISTERED_BY" /></td>

							</tr>

						</tbody>

					</table>

				</fieldset>

			</div>

			<div class="well">

				<fieldset>

					<legend><h4>Configuration parameters</h4></legend>

					<table class="table table-bordered table-striped">

						<tbody>

							<xsl:for-each select=".//EXTRA_FIELDS/FIELD">

								<tr>

									<td width="25%"><xsl:value-of select="./key" /></td>

									<td><xsl:value-of select="./value" /></td>

								</tr>

							</xsl:for-each>

						</tbody>

					</table>

				</fieldset>

			</div>

			<xsl:for-each select="//INTERFACE">

				<div class="well">

					<fieldset>

						<legend><h4>Interface: <xsl:value-of select="./@typology" /></h4></legend>

						<table class="table table-bordered table-striped">

							<tbody>

								<xsl:for-each select="@*|.//*[string-length(normalize-space(text())) &gt; 0]|.//*[name() != 'INTERFACE_EXTRA_FIELD']/@*">

									<tr>

										<td width="25%">

											<xsl:choose>

												<xsl:when test="name() = 'INTERFACE_EXTRA_FIELD'">

													<xsl:value-of select="@name" />

												</xsl:when>

												<xsl:otherwise>

													<xsl:value-of select="local-name(.)" />		

												</xsl:otherwise>

											</xsl:choose>

										</td>

										<td><xsl:value-of select="." /></td>

									</tr>

								</xsl:for-each>

							</tbody>

						</table>

					</fieldset>

				</div>

			</xsl:for-each>

		</div>

	</xsl:template>

</xsl:stylesheet> 

for \$x in 

	collection('/db/DRIVER/RepositoryServiceResources/RepositoryServiceResourceType')[.//RESOURCE_IDENTIFIER/@value='$dsId$' or .//DATASOURCE_ORIGINAL_ID = '$dsId$']//INTERFACE[@id='$ifaceId$']

let \$repoId := \$x/../../../../HEADER/RESOURCE_IDENTIFIER/@value/string()

return 

	<api>

		<id>{\$x/@id/string()}</id>

		<label>{\$x/@label/string()}</label>

		<removable>{\$x/@removable/string()}</removable>

		<protocol>{\$x/ACCESS_PROTOCOL/text()}</protocol>

		<repo 

			id="{\$repoId}" 

			country="{\$x/../../COUNTRY/text()}" 

			prefix="{\$x/../..//EXTRA_FIELDS/FIELD[./key='NamespacePrefix']/value}"

			type="{\$x/../../TYPOLOGY/text()}"

			email="{\$x/../../ADMIN_INFO/text()}">

			{\$x/../../OFFICIAL_NAME/text()}

		</repo>

		<commonParams>

			<param name="id">{\$x/@id/string()}</param>

			<param name="label">{\$x/@label/string()}</param>