D-Net

import org.dom4j.Document;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

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

import org.springframework.ui.ModelMap;

import com.google.common.collect.Sets;

import com.google.gson.Gson;

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

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

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

	private String validatorAddress;

	private String validatorServiceAddress;

	public class RepoHIWorkflow implements Comparable<RepoHIWorkflow> {

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

		/**

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

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

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

				final Node currentNode = (Node) o;

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

				final String value = currentNode.getText();

			}

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

		} catch (final Exception e) {

		final Gson gson = new Gson();

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

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

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

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

	}

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;

	@Resource

	private UniqueServiceLocator serviceLocator;

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

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

		final RepoInterfaceEntry ifc = new RepoInterfaceEntry();

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

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

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

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

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

			final Node n = (Node) o;

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

			final String value = n.getText();

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

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

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

					}

				}

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

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.cache.annotation.CacheEvict;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.http.HttpStatus;

import com.google.common.collect.Maps;

import com.google.gson.Gson;

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.is.lookup.rmi.ISLookUpDocumentNotFoundException;

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

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

@Controller

public class RepoInternalController {

	@Resource

	private UniqueServiceLocator serviceLocator;

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

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

	}

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

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

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

	}

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

	}

	@CacheEvict("repoUIJsonCache")

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

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

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

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

		return repoUIUtils.getApi(repoId, ifaceId);

	}

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

	public @ResponseBody boolean updateRepoApi(

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

			@RequestParam(value = "accessParams", required = false) final String accessParamsJson,

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

		if (!StringUtils.isEmpty(accessParamsJson)) {

		}

		return true;

	}

	public @ResponseBody boolean updateRepoApi(

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

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

	}

	@CacheEvict("repoUIJsonCache")

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

		return true;

	}

		log.debug("RESET COMPLIANCE");

		return true;

	}

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

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

	}

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

		}

	}

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

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

import java.util.List;

	private String label;

	private boolean removable = false;

	private String collDate = "";

	private String downloadObjId = "";

	private String repoType;

	private String email;

	public String getLabel() {

		return label;

		return removable;

	}

		this.removable = removable;

	}

			<fieldset>

				<legend>General Info</legend>

				<ng-simple-edit-field label="Datasource ID (template: 12Chars_____::theId)" selection="repo.id" regex="^\w{12}::\w+\$"></ng-simple-edit-field>

			</fieldset>

			<fieldset>

				<legend>Contacts</legend>

			</fieldset>

			<fieldset>

				<legend>Geographical Info</legend>

				<ng-simple-edit-field label="Latitude" selection="repo.latitude" type="NUMBER"></ng-simple-edit-field>

				<ng-simple-edit-field label="Longitude" selection="repo.longitude" type="NUMBER"></ng-simple-edit-field>

			</fieldset>

			<fieldset>

				<legend>Technical Info</legend>

			</fieldset>

			<br /><br />

			        	<a role="menuitem" tabindex="-1" href="javascript:void(0)" ng-click="overrideApiCompliance(l.name)">override to <b>{{l.name}}</b> (<i>{{l.desc}}</i>)</a>

			        </li>

					<li class="divider" role="presentation" ng-show="p.otherValue"></li>

			    </ul>

			</div>

		</div>

			<ng-fixed-value-field label="Typology" value="api.typology"></ng-fixed-value-field>

			<ng-api-id-field label="Api ID" prefix="api_________::{{repo.origId}}::" exclusion="repo.apis" selection="api.id"></ng-api-id-field>

			<!-- <ng-select-vocabulary-field label="Typology" vocabulary="values.types" selection="api.typology"></ng-select-vocabulary-field> -->

			<ng-simple-edit-field 

				ng-repeat="param in currentParams | filter: { functionPopulated : false }" 

				optional="{{param.optional}}" 

				regex="{{param.regex}}" 

				type="{{param.type}}"></ng-simple-edit-field>

			<ng-simple-select-field 

				ng-repeat="param in currentParams | filter: { functionPopulated : true, type : 'TEXT' }" 

				refresh-function="listValidValuesForParam(param.name)"

				optional="{{param.optional}}"></ng-simple-select-field>

			<ng-multi-select-field 

				ng-repeat="param in currentParams | filter: { functionPopulated : true, type : 'LIST' }" 

				refresh-function="listValidValuesForParam(param.name)"

				optional="{{param.optional}}"></ng-multi-select-field>

			<div class="form-group">

				<div class="col-sm-offset-3 col-sm-9">

	$scope.$watch('repo', function() {

		if ($scope.repo) {

			$scope.api = {

			};

		}

	});

		$scope.selectedTypology = '';

		$scope.repo = {};

		$scope.api = {};

		$scope.validValues = [];

	}

	$scope.registerApi = function() {

		if (confirm('Add new api to repository \n\n' + $scope.repo.name + '?')) {

			$scope.showSpinner();

			$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";

			$http.post('repoApi.new', $.param({

			return;

		}

			$scope.showError("Access Protocol is missing");

			return;	

		}

			$scope.showError("BaseUrl is missing");

			return;

		}

		$scope.validValues[key] = [];

		$scope.showSpinner();

		$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";

		$http.post('listValidValuesForParam.do', $.param({

			'param'    : param,

		})).success(function(data) {

			$scope.hideSpinner();

			$scope.validValues[key] = data;

				enableCellEditOnFocus: false,

				enableHighlighting: true,

				filterOptions: $scope.filterBrowseData,

				columnDefs: [

				             ]

		};

		$scope.repo = {

			latitude : '0.0',

			longitude : '0.0',

		};

	}

	$scope.registerRepo = function() {

			$scope.showSpinner();

			$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";

			$http.post('repo.new', $.param({

				'repo'  : JSON.stringify($scope.repo)

			})).success(function(res) {

	<packaging>jar</packaging>

	<version>4.0.18-SNAPSHOT</version>

	<scm>

	</scm>

	<dependencies>

		<dependency>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

		</dependency>

		<dependency>

			<groupId>junit</groupId>