/ - Diff - D-Net - D-Net project tracking tool

     package eu.dnetlib.datasource.publisher.repository;
     import java.util.List;
     import eu.dnetlib.datasource.publisher.model.db.SearchInterfacesEntry;
     import org.springframework.data.jpa.repository.JpaRepository;
     import org.springframework.stereotype.Repository;
     /**
      * Created by claudio on 12/04/2017.
      */
     @Repository
     public interface SearchApiRepository extends JpaRepository<SearchInterfacesEntry, String> {
     	SearchInterfacesEntry findOneById(String id);
     	List<SearchInterfacesEntry> findByRepoidContainingOrRepoNameContainingOrAlternativeNameContainingOrRepoPrefixContainingOrRepoOrganizationContainingAllIgnoreCase(
     			String repoId,
     			String repoName,
     			String alternativeName,
     			String repoPrefix,
     			String repoOrganization);
+    }

     package eu.dnetlib.datasource.publisher.clients;
     import java.util.List;
     import java.util.Queue;
     import java.util.concurrent.*;
     import javax.annotation.Resource;
     import com.google.common.collect.Lists;
     import com.google.common.util.concurrent.*;
     import eu.dnetlib.datasource.publisher.ApiException;
     import eu.dnetlib.datasource.publisher.clients.utils.IndexDsInfo;
     import eu.dnetlib.datasource.publisher.clients.utils.IndexRecordsInfo;
     import eu.dnetlib.datasource.publisher.model.AggregationInfo;
     import eu.dnetlib.datasource.publisher.model.AggregationStage;
     import eu.dnetlib.datasource.publisher.model.DatasourceResponse;
     import eu.dnetlib.datasource.publisher.model.db.*;
     import eu.dnetlib.datasource.publisher.repository.*;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.data.domain.Pageable;
     import org.springframework.data.domain.Slice;
     import org.springframework.util.concurrent.ListenableFuture;
     import org.springframework.util.concurrent.ListenableFutureCallback;
     /**
      * Created by claudio on 20/10/2016.
      */
     public class DatasourceInfoRetriever {
     	private static final Log log = LogFactory.getLog(DatasourceInfoRetriever.class);
     	@Autowired
     	private MongoLoggerClient mongoLoggerClient;
     	@Autowired
     	private DatasourceIndexClient datasourceIndexClient;
     	@Autowired
     	private DatasourceRepository dsRepository;
     	@Autowired
     	private SearchApiRepository searchApiRepository;
     	@Autowired
     	private CountryTermRepository countryTermRepository;
     	@Autowired
     	private TypologyTermRepository typologyTermRepository;
     	@Autowired
     	private ProtocolTermRepository protocolTermRepository;
     	@Autowired
     	private CompatibilityTermRepository compatibilityTermRepository;
     	@Autowired
     	private ActivationTermRepository activationTermRepository;
     	@Resource(name = "datasourceIsLookupClient")
     	private ISLookupClient isLookupClient;
     	private ListeningExecutorService service;
     	private final static int WORKERS = 100;
     	@Value("${datasource.publisher.timeout}")
     	private int timeout = 10;
     	public DatasourceInfoRetriever() {
     		service = MoreExecutors.listeningDecorator(
     				new ScheduledThreadPoolExecutor(WORKERS,
     						new ThreadFactoryBuilder().setNameFormat("datasource-info-retriever-%d").build()));
+    	}
     	public List<String> listIds(final Pageable pageable) throws ApiException {
     		return dsRepository.findAll(pageable)
     				.map(d -> d.getId())
     				.getContent();
+    	}
     	public List<DatasourceResponse> searchByName(final String name, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by name '%s'", name));
     		final ListenableFuture<Slice<Datasource>> c =
     				dsRepository.findByOfficialnameContainingOrEnglishnameContainingAllIgnoreCase(name, name, pageable);
     		c.addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	public List<DatasourceResponse> searchByCountry(final String country, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by country '%s'", country));
     		dsRepository.findByOrganizationsCountryIgnoreCase(country, pageable).addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	public List<DatasourceResponse> searchByContactemail(final String email, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by email '%s'", email));
     		dsRepository.findByContactemailContainingAllIgnoreCase(email, pageable).addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	private ListenableFutureCallback<Slice<Datasource>> getSearchCallback(final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final List<DatasourceResponse> datasourceResponse) {
     		return new ListenableFutureCallback<Slice<Datasource>>() {
     			@Override
     			public void onSuccess(final Slice<Datasource> datasources) {
     				datasources.forEach(d -> {
     					final DatasourceResponse response = new DatasourceResponse();
     					response.setDatasource(d);
     					getAggregationHistory(d.getId(), outerLatch, errors, response);
     					getIndexDsInfo(d.getId(), outerLatch, errors, response);
     					datasourceResponse.add(response);
     				});
     				outerLatch.countDown();
+    			}
     			@Override
     			public void onFailure(final Throwable e) {
     				errors.offer(e);
     				outerLatch.countDown();
+    			}
     		};
+    	}
     	public ClientResponse getInfo(final String dsId) {
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		final DatasourceResponse datasourceResponse = new DatasourceResponse();
     		getAggregationHistory(dsId, outerLatch, errors, datasourceResponse);
     		dsRepository.findOneById(dsId).addCallback(new ListenableFutureCallback<Datasource>() {
     			@Override
     			public void onSuccess(final Datasource datasource) {
     				datasourceResponse.setDatasource(datasource);
     				outerLatch.countDown();
+    			}
     			@Override
     			public void onFailure(final Throwable e) {
     				errors.offer(e);
     				outerLatch.countDown();
+    			}
     		});
     		getIndexDsInfo(dsId, outerLatch, errors, datasourceResponse);
     		waitLatch(outerLatch, errors, timeout);
     		/*
     		if (!errors.isEmpty()) {
     			datasourceResponse.getResponseHeader().setError(Joiner.on("\n").skipNulls().join(errors.stream().map(e -> e.getMessage()).collect(Collectors.toList())));
     			log.error(Joiner.on("\n").skipNulls().join(errors.stream().map(e -> ExceptionUtils.getFullStackTrace(e)).collect(Collectors.toList())));
+    		}
     		*/
     		return new ClientResponse().datasourceInfo(datasourceResponse).errors(errors);
+    	}
     	public void setManaged(final String id, final boolean managed) {
     		log.info(String.format("setting managed = '%s' for ds '%s'", managed, id));
     		dsRepository.setManaged(id, managed);
+    	}
     	public List<SearchInterfacesEntry> searchInterface(final String field, final String value) {
     		switch (field) {
     		case "__SEARCH__":
     			return searchApiRepository
     					.findByRepoidContainingOrRepoNameContainingOrAlternativeNameContainingOrRepoPrefixContainingOrRepoOrganizationContainingAllIgnoreCase(
     							value, value, value, value, value);
     		case "country":
     			break;
     		case "type":
     			break;
     		case "protocol":
     			break;
     		case "compliance":
     			break;
     		case "active":
     			break;
     		default:
     			throw new IllegalArgumentException("");
+    		}
     		return null;
+    	}
     	public List<CountryTerm> browseCountries() {
     		return countryTermRepository.findAll();
+    	}
     	public List<TypologyTerm> browseTypologies() {
     		return typologyTermRepository.findAll();
+    	}
     	public List<ProtocolTerm> browseProtocols() {
     		return protocolTermRepository.findAll();
+    	}
     	public List<CompatibilityTerm> browseCompatibility() {
     		return compatibilityTermRepository.findAll();
+    	}
     	public List<ActivationTerm> browseActivation() {
     		return activationTermRepository.findAll();
+    	}
     	private void getIndexDsInfo(final String dsId,
     			final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final DatasourceResponse datasourceResponse) {
     		Futures.addCallback(
     				service.submit(() -> isLookupClient.calculateCurrentIndexDsInfo()),
     				new FutureCallback<IndexDsInfo>() {
     					public void onSuccess(final IndexDsInfo info) {
     						final CountDownLatch innerLatch = new CountDownLatch(1);
     						Futures.addCallback(
     								service.submit(() -> datasourceIndexClient.getIndexInfo(dsId, info)),
     								new FutureCallback<IndexRecordsInfo>() {
     									public void onSuccess(IndexRecordsInfo info) {
     										datasourceResponse.setIndexRecords(info.getCount()).setLastIndexingDate(info.getDate());
     										innerLatch.countDown();
+    									}
     									public void onFailure(Throwable e) {
     										errors.offer(e);
     										innerLatch.countDown();
+    									}
     						});
     						waitLatch(innerLatch, errors, timeout);
     						outerLatch.countDown();
+    					}
     					public void onFailure(final Throwable e) {
     						errors.offer(e);
     						outerLatch.countDown();
+    					}
     		});
+    	}
     	private void getAggregationHistory(final String dsId,
     			final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final DatasourceResponse datasourceResponse) {
     		Futures.addCallback(
     				service.submit(() -> mongoLoggerClient.getAggregationHistory(dsId)),
     				new FutureCallback<List<AggregationInfo>>() {
     					public void onSuccess(List<AggregationInfo> info) {
     						setAggregationHistory(datasourceResponse, info);
     						outerLatch.countDown();
+    					}
     					public void onFailure(Throwable e) {
     						errors.offer(e);
     						outerLatch.countDown();
+    					}
     		});
+    	}
     	private void setAggregationHistory(DatasourceResponse datasourceResponse, final List<AggregationInfo> info) {
     		datasourceResponse.setAggregationHistory(info);
     		if (!info.isEmpty()) {
     			datasourceResponse
     					.setLastCollection(info.stream().filter(a -> AggregationStage.COLLECT.equals(a.getAggregationStage())).findFirst().get())
     					.setLastTransformation(info.stream().filter(a -> AggregationStage.TRANSFORM.equals(a.getAggregationStage())).findFirst().get());
+    		}
+    	}
     	private void waitLatch(final CountDownLatch latch, final Queue<Throwable> errors, final int waitSeconds) {
     		try {
     			if (!latch.await(waitSeconds, TimeUnit.SECONDS)) {
     				errors.offer(new TimeoutException("Waiting for requests to complete has timed out."));
+    			}
     		} catch (final InterruptedException e) {
     			errors.offer(e);
+    		}
+    	}
+    }

     package eu.dnetlib.datasource.publisher.repository;
     import java.util.List;
     import eu.dnetlib.datasource.publisher.model.db.SearchInterfacesEntry;
     import org.springframework.data.jpa.repository.JpaRepository;
     import org.springframework.stereotype.Repository;
     /**
      * Created by claudio on 12/04/2017.
      */
     @Repository
     public interface SearchInterfaceRepository extends JpaRepository<SearchInterfacesEntry, String> {
     	SearchInterfacesEntry findOneById(String id);
     	List<SearchInterfacesEntry> findByRepoidContainingOrRepoNameContainingOrAlternativeNameContainingOrRepoPrefixContainingOrRepoOrganizationContainingAllIgnoreCase(
     			String repoId,
     			String repoName,
     			String alternativeName,
     			String repoPrefix,
     			String repoOrganization);
+    }

     package eu.dnetlib.datasource.publisher.repository;
     import java.util.List;
     import eu.dnetlib.datasource.publisher.model.db.Api;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.lang3.RandomStringUtils;
     import org.springframework.data.jpa.repository.JpaRepository;
     import org.springframework.data.jpa.repository.Query;
     import org.springframework.stereotype.Repository;
     /**
      * Created by claudio on 15/06/2017.
      */
     @Repository
     public interface ApiRepository extends JpaRepository<Api, String> {
     	String ID_PREFIX = "api_________::";
     	static String createId(Api api) {
     		return ID_PREFIX + api.getDatasource() + "::" + RandomStringUtils.randomAlphanumeric(8);
+    	}
     	@Query("select a from Api a where a.datasource = ?1")
     	List<Api> findByDatasource(String dsId);
+    }

     	@Query("update Datasource d set d.managed = ?2 where d.id = ?1")
     	void setManaged(String id, boolean managed);
     	@Modifying
     	@Transactional
     	@Query("update Datasource d set d.officialname = ?2 where d.id = ?1")
     	void setOfficialname(String id, String officialname);
     	@Modifying
     	@Transactional
     	@Query("update Datasource d set d.englishname = ?2 where d.id = ?1")
     	void setEnglishname(String id, String englishname);
     	@Modifying
     	@Transactional
     	@Query("update Datasource d set d.latitude = ?2 where d.id = ?1")
     	void setLatitude(String id, Double latitude);
     	@Modifying
     	@Transactional
     	@Query("update Datasource d set d.longitude = ?2 where d.id = ?1")
     	void setLongitude(String id, Double longitude);
+    }

     import java.io.Serializable;
     import java.util.Objects;
     import javax.persistence.Embeddable;
     import javax.persistence.JoinColumn;
     import javax.persistence.ManyToOne;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
     import com.google.common.collect.ComparisonChain;
     /**
      * Created by claudio on 13/04/2017.
      */
     @Embeddable
     @JsonIgnoreProperties(ignoreUnknown = true)
     public class ApiParamKey implements Serializable {
     	@JsonIgnore
     	@ManyToOne
     	@JoinColumn(name = "api")
     	private Api api = null;
     	private String param;
     	private String value;
     	public ApiParamKey() {}
     	public String getParam() {
     		return param;
+    	}
     	public String getValue() {
     		return value;
+    	}
     	public ApiParamKey setParam(final String param) {
     		this.param = param;
     		return this;
+    	}
     	public ApiParamKey setValue(final String value) {
     		this.value = value;
     		return this;
     	public Api getApi() {
     		return api;
+    	}
     	public void setApi(final Api api) {
     		this.api = api;
+    	}
     	@Override
     	public int hashCode() {
     		return Objects.hash(getParam(), getValue());
     		return Objects.hash(getParam(), getApi().getId());
+    	}
     	@Override
-...
     		ApiParamKey apk = (ApiParamKey) o;
     		return ComparisonChain.start()
     				.compare(getParam(), apk.getParam())
     				.compare(getValue(), apk.getValue())
     				.compare(getApi(), apk.getApi())
     				.result() == 0;
+    	}
+    }

     import java.util.Set;
     import javax.persistence.*;
     import com.fasterxml.jackson.annotation.JsonAutoDetect;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import io.swagger.annotations.ApiModel;
-...
      */
     @Entity
     @Table(name = "dsm_organizations")
     @JsonAutoDetect
     //@JsonAutoDetect
     @ApiModel(value = "Organization model", description = "provides organization details")
     public class Organization {
-...
     			mappedBy = "organizations")
     	private Set<Datasource> datasources;
     	public Organization() {}
     	public String getId() {
     		return id;
+    	}

     import java.util.Set;
     import javax.persistence.*;
     import com.fasterxml.jackson.annotation.JsonAutoDetect;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import com.google.common.collect.ComparisonChain;
     import com.google.gson.Gson;
     import io.swagger.annotations.ApiModel;
-...
      */
     @Entity
     @Table(name = "dsm_api")
     @JsonAutoDetect
     @ApiModel(value = "Datasource Api model", description = "describes the datasource api")
     public class Api {
     public class Api implements Comparable<Api> {
     	@Id
     	private String id = null;
     	private String protocol = null;
     	@JsonIgnore
     	@ManyToOne
     	@JoinColumn(name = "datasource")
     	private Datasource datasource = null;
     	private String datasource = null;
     	private String contentdescription = null;
     	private Boolean active = false;
     	private Boolean removable = false;
-...
     	private String baseurl = null;
     	@OneToMany(mappedBy="api", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     	@OneToMany(mappedBy = "id.api", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     	private Set<Apiparam> apiparam;
     	public Api() {}
     	public String getId() {
     		return id;
+    	}
-...
     		return protocol;
+    	}
     	public Datasource getDatasource() {
     	public String getDatasource() {
     		return datasource;
+    	}
-...
     		return this;
+    	}
     	public Api setDatasource(final Datasource datasource) {
     	public Api setDatasource(final String datasource) {
     		this.datasource = datasource;
     		return this;
+    	}
-...
     		return new Gson().toJson(this);
+    	}
     	@Override
     	public int compareTo(final Api a) {
     		return ComparisonChain.start()
     				.compare(getId(), a.getId())
     				.result();
+    	}
+    }

     package eu.dnetlib.datasource.publisher.model.db;
     import javax.persistence.*;
     import javax.persistence.Entity;
     import javax.persistence.Id;
     import javax.persistence.Table;
     import com.fasterxml.jackson.annotation.JsonAutoDetect;
     import io.swagger.annotations.ApiModel;
     /**
      * Created by claudio on 13/04/2017.
      */
     @Entity
     @Table(name = "dsm_identities")
     @JsonAutoDetect
     //@JsonAutoDetect
     @ApiModel(value = "Identities model", description = "provides identity details")
     public class Identity {
-...
     	private String issuertype;
     	public String pid() {
     	public Identity() {}
     	public String getPid() {
     		return this.pid;
+    	}
     	public String issuertype() {
     	public String getIssuertype() {
     		return this.issuertype;
+    	}

     package eu.dnetlib.datasource.publisher.model.db;
     import javax.persistence.*;
     import javax.persistence.EmbeddedId;
     import javax.persistence.Entity;
     import javax.persistence.Table;
     import com.fasterxml.jackson.annotation.JsonAutoDetect;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
     import io.swagger.annotations.ApiModel;
     /**
-...
      */
     @Entity
     @Table(name = "dsm_apiparams")
     @JsonAutoDetect
     @JsonIgnoreProperties(ignoreUnknown = true)
     @ApiModel(value = "Datasource Api params model", description = "describes the datasource api params")
     public class Apiparam {
     	@JsonIgnore
     	@EmbeddedId
     	private ApiParamKey id;
     	@JsonIgnore
     	@ManyToOne
     	@JoinColumn(name = "api")
     	private Api api = null;
     	private String value;
     	public Apiparam() {}
     	public ApiParamKey getId() {
     		return id;
+    	}
     	public Api getApi() {
     		return api;
+    	}
     	public Apiparam setId(final ApiParamKey id) {
     		this.id = id;
     		return this;
+    	}
     	public Apiparam setApi(final Api api) {
     		this.api = api;
     		return this;
     	public String getValue() {
     		return value;
+    	}
     	public void setValue(final String value) {
     		this.value = value;
+    	}
     	public String getParam() {
     		return id.getParam();
+    	}
     	public void setParam(final String param) {
     		getId().setParam(param);
+    	}
+    }

     import java.util.Set;
     import javax.persistence.*;
     import com.fasterxml.jackson.annotation.JsonAutoDetect;
     import io.swagger.annotations.ApiModel;
     /**
-...
      */
     @Entity
     @Table(name = "dsm_datasources")
     @JsonAutoDetect
     //@JsonAutoDetect
     @ApiModel(value = "Datasource model", description = "provides datasource details")
     public class Datasource {
     	@Id
     	private String id = null;
     	private String officialname = null; //findByOfficialnameContainingOrEnglishnameContaining
     	private String officialname = null;
     	private String englishname = null;
     	private String websiteurl = null;
     	private String logourl = null;
-...
     	private Boolean managed;
     	@OneToMany(mappedBy="datasource", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     	/*
     	@JsonIgnore
     	@OneToMany(mappedBy = "datasource", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
     	private Set<Api> api = null;
     	*/
     	@ManyToMany(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, fetch = FetchType.EAGER)
     	@JoinTable(
-...
     			inverseJoinColumns = @JoinColumn(name="pid"))
     	private Set<Identity> identities;
     	public Datasource() {}
     	public String getId() {
     		return id;
+    	}
-...
     		return managed;
+    	}
     	public Set<Api> getApi() {
     		return api;
+    	}
     	public Set<Organization> getOrganizations() {
     		return organizations;
+    	}
-...
     		return this;
+    	}
     	public Datasource setApi(final Set<Api> api) {
     		this.api = api;
     		return this;
+    	}
     	public Datasource setOrganizations(final Set<Organization> organizations) {
     		this.organizations = organizations;
     		return this;

modules/dnet-datasource-rest-api/trunk/src/main/java/eu/dnetlib/datasource/publisher/model/AggregationStage.java
18	18	case "TRANSFORM":
19	19	case "TRANSFORMATION":
20	20	return AggregationStage.TRANSFORM;
	21
21	22	}
22	23	throw new IllegalArgumentException("invalid AggregationStage: " + s);
23	24	}

     import static com.mongodb.client.model.Filters.and;
     import static com.mongodb.client.model.Filters.eq;
     import static com.mongodb.client.model.Filters.regex;
     /**
      * Created by claudio on 20/10/2016.
-...
     		return and(
     				eq("parentDatasourceId", dsId),
     				eq("system:profileFamily", "aggregator"),
     				eq("system:isCompletedSuccessfully", "true"));
     				eq("system:isCompletedSuccessfully", "true"),
     				regex("system:wfName", "(collect|transform)", "i"));
+    	}
     	private synchronized MongoCollection<Document> getCollection() {
-...
     	@Cacheable("datasources-mongo-cache")
     	public List<AggregationInfo> getAggregationHistory(final String dsId) throws ApiException {
     		log.warn("getAggregationHistory(): not using cache");
     		log.warn(String.format("getAggregationHistory(dsId = %s): not using cache", dsId));
     		final Bson query = getQuery(dsId);
     		return Utils.stream(getCollection().find(query).projection(fields).limit(limit).sort(dbo("system:startHumanDate", -1)).iterator())
     				.map(getMapper())
     				.filter(ai -> ai.getNumberOfRecords() >= 0 && StringUtils.isNotBlank(ai.getDate()))

     package eu.dnetlib.datasource.publisher.clients;
     import java.util.List;
     import java.util.Queue;
     import java.util.concurrent.*;
     import javax.annotation.Resource;
     import com.google.common.collect.Lists;
     import com.google.common.util.concurrent.*;
     import eu.dnetlib.datasource.publisher.ApiException;
     import eu.dnetlib.datasource.publisher.clients.utils.IndexDsInfo;
     import eu.dnetlib.datasource.publisher.clients.utils.IndexRecordsInfo;
     import eu.dnetlib.datasource.publisher.model.AggregationInfo;
     import eu.dnetlib.datasource.publisher.model.AggregationStage;
     import eu.dnetlib.datasource.publisher.model.DatasourceResponse;
     import eu.dnetlib.datasource.publisher.model.db.*;
     import eu.dnetlib.datasource.publisher.model.db.SearchInterfacesEntry;
     import eu.dnetlib.datasource.publisher.repository.*;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.lang3.exception.ExceptionUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.http.HttpStatus;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.data.domain.Pageable;
     import org.springframework.data.domain.Slice;
     import org.springframework.util.concurrent.ListenableFuture;
     import org.springframework.util.concurrent.ListenableFutureCallback;
     /**
      * Created by claudio on 20/10/2016.
      */
     public class DatasourceDao {
     	private static final Log log = LogFactory.getLog(DatasourceDao.class);
     	@Autowired
     	private MongoLoggerClient mongoLoggerClient;
     	@Autowired
     	private DatasourceIndexClient datasourceIndexClient;
     	@Autowired
     	private DatasourceRepository dsRepository;
     	@Autowired
     	private SearchInterfaceRepository searchInterfaceRepository;
     	@Autowired
     	private CountryTermRepository countryTermRepository;
     	@Autowired
     	private TypologyTermRepository typologyTermRepository;
     	@Autowired
     	private ProtocolTermRepository protocolTermRepository;
     	@Autowired
     	private CompatibilityTermRepository compatibilityTermRepository;
     	@Autowired
     	private ActivationTermRepository activationTermRepository;
     	@Autowired
     	private ApiRepository apiRepository;
     	@Resource(name = "datasourceIsLookupClient")
     	private ISLookupClient isLookupClient;
     	private ListeningExecutorService service;
     	private final static int WORKERS = 100;
     	@Value("${datasource.publisher.timeout}")
     	private int timeout = 10;
     	public DatasourceDao() {
     		service = MoreExecutors.listeningDecorator(
     				new ScheduledThreadPoolExecutor(WORKERS,
     						new ThreadFactoryBuilder().setNameFormat("datasource-info-retriever-%d").build()));
+    	}
     	public List<String> listIds(final Pageable pageable) throws ApiException {
     		return dsRepository.findAll(pageable)
     				.map(d -> d.getId())
     				.getContent();
+    	}
     	public List<DatasourceResponse> searchByName(final String name, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by name '%s'", name));
     		final ListenableFuture<Slice<Datasource>> c =
     				dsRepository.findByOfficialnameContainingOrEnglishnameContainingAllIgnoreCase(name, name, pageable);
     		c.addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	public List<DatasourceResponse> searchByCountry(final String country, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by country '%s'", country));
     		//dsRepository.findByOrganizationsCountryIgnoreCase(country, pageable).addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	public List<DatasourceResponse> searchByContactemail(final String email, final Pageable pageable) {
     		final List<DatasourceResponse> datasourceResponse = Lists.newArrayList();
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		log.debug(String.format("search ds by email '%s'", email));
     		dsRepository.findByContactemailContainingAllIgnoreCase(email, pageable).addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));
     		waitLatch(outerLatch, errors, timeout);
     		return datasourceResponse;
+    	}
     	private ListenableFutureCallback<Slice<Datasource>> getSearchCallback(final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final List<DatasourceResponse> datasourceResponse) {
     		return new ListenableFutureCallback<Slice<Datasource>>() {
     			@Override
     			public void onSuccess(final Slice<Datasource> datasources) {
     				datasources.forEach(d -> {
     					final DatasourceResponse response = new DatasourceResponse();
     					response.setDatasource(d);
     					getAggregationHistory(d.getId(), outerLatch, errors, response);
     					getIndexDsInfo(d.getId(), outerLatch, errors, response);
     					datasourceResponse.add(response);
     				});
     				outerLatch.countDown();
+    			}
     			@Override
     			public void onFailure(final Throwable e) {
     				errors.offer(e);
     				outerLatch.countDown();
+    			}
     		};
+    	}
     	public ClientResponse getInfo(final String dsId) {
     		final CountDownLatch outerLatch = new CountDownLatch(3);
     		final Queue<Throwable> errors = new ConcurrentLinkedQueue<>();
     		final DatasourceResponse datasourceResponse = new DatasourceResponse();
     		getAggregationHistory(dsId, outerLatch, errors, datasourceResponse);
     		dsRepository.findOneById(dsId).addCallback(new ListenableFutureCallback<Datasource>() {
     			@Override
     			public void onSuccess(final Datasource datasource) {
     				datasourceResponse.setDatasource(datasource);
     				outerLatch.countDown();
+    			}
     			@Override
     			public void onFailure(final Throwable e) {
     				log.error(ExceptionUtils.getStackTrace(e));
     				errors.offer(e);
     				outerLatch.countDown();
+    			}
     		});
     		getIndexDsInfo(dsId, outerLatch, errors, datasourceResponse);
     		waitLatch(outerLatch, errors, timeout);
     		/*
     		if (!errors.isEmpty()) {
     			datasourceResponse.getResponseHeader().setError(Joiner.on("\n").skipNulls().join(errors.stream().map(e -> e.getMessage()).collect(Collectors.toList())));
     			log.error(Joiner.on("\n").skipNulls().join(errors.stream().map(e -> ExceptionUtils.getFullStackTrace(e)).collect(Collectors.toList())));
+    		}
     		*/
     		return new ClientResponse().datasourceInfo(datasourceResponse).errors(errors);
+    	}
     	public void setManaged(final String id, final boolean managed) {
     		log.info(String.format("setting managed = '%s' for ds '%s'", managed, id));
     		dsRepository.setManaged(id, managed);
+    	}
     	public List<SearchInterfacesEntry> searchInterface(final String field, final String value) {
     		switch (field) {
     		case "__SEARCH__":
     			return searchInterfaceRepository
     					.findByRepoidContainingOrRepoNameContainingOrAlternativeNameContainingOrRepoPrefixContainingOrRepoOrganizationContainingAllIgnoreCase(
     							value, value, value, value, value);
     		case "country":
     			break;
     		case "type":
     			break;
     		case "protocol":
     			break;
     		case "compliance":
     			break;
     		case "active":
     			break;
     		default:
     			throw new IllegalArgumentException("");
+    		}
     		return null;
+    	}
     	public List<CountryTerm> browseCountries() {
     		return countryTermRepository.findAll();
+    	}
     	public List<TypologyTerm> browseTypologies() {
     		return typologyTermRepository.findAll();
+    	}
     	public List<ProtocolTerm> browseProtocols() {
     		return protocolTermRepository.findAll();
+    	}
     	public List<CompatibilityTerm> browseCompatibility() {
     		return compatibilityTermRepository.findAll();
+    	}
     	public List<ActivationTerm> browseActivation() {
     		return activationTermRepository.findAll();
+    	}
     	public List<Api> getApi(final String dsId) {
     		return apiRepository.findByDatasource(dsId);
+    	}
     	public void deleteApi(final String apiId) {
     		apiRepository.delete(apiId);
     		log.info(String.format("deleted api '%s'", apiId));
+    	}
     	public void addApi(final Api api) {
     		if (StringUtils.isBlank(api.getId())) {
     			api.setId(ApiRepository.createId(api));
     			log.info(String.format("missing api id, created '%s'"));
+    		}
     		apiRepository.save(api);
+    	}
     	public boolean exist(final Datasource d) throws ApiException {
     		try {
     			return dsRepository.findOneById(d.getId()).get() != null;
     		} catch (Exception e) {
     			log.error(e);
     			throw new ApiException(HttpStatus.SC_INTERNAL_SERVER_ERROR, String.format("error retrieving datasource information '%s'", d.getId()), e);
+    		}
+    	}
     	public Datasource save(final Datasource d) {
     		log.info(String.format("saving datasource '%s'", d.getId()));
     		final Datasource datasource = dsRepository.save(d);
     		log.info(String.format("saved datasource '%s'", datasource.getId()));
     		return datasource;
+    	}
     	public void updateOfficialName(final String dsId, final String officialname) {
     		dsRepository.setOfficialname(dsId, officialname);
     		log.info(String.format("updated datasource '%s' with officialname '%s'", dsId, officialname));
+    	}
     	public void updateEnglishName(final String dsId, final String englishname) {
     		dsRepository.setEnglishname(dsId, englishname);
     		log.info(String.format("updated datasource '%s' with englishname '%s'", dsId, englishname));
+    	}
     	public void updateLatitude(final String dsId, final Double latitude) {
     		dsRepository.setLatitude(dsId, latitude);
     		log.info(String.format("updated datasource '%s' with latitude '%s'", dsId, latitude));
+    	}
     	public void updateLongitude(final String dsId, final Double longitude) {
     		dsRepository.setLongitude(dsId, longitude);
     		log.info(String.format("updated datasource '%s' with longitude '%s'", dsId, longitude));
+    	}
     	private void getIndexDsInfo(final String dsId,
     			final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final DatasourceResponse datasourceResponse) {
     		Futures.addCallback(
     				service.submit(() -> isLookupClient.calculateCurrentIndexDsInfo()),
     				new FutureCallback<IndexDsInfo>() {
     					public void onSuccess(final IndexDsInfo info) {
     						final CountDownLatch innerLatch = new CountDownLatch(1);
     						Futures.addCallback(
     								service.submit(() -> datasourceIndexClient.getIndexInfo(dsId, info)),
     								new FutureCallback<IndexRecordsInfo>() {
     									public void onSuccess(IndexRecordsInfo info) {
     										datasourceResponse.setIndexRecords(info.getCount()).setLastIndexingDate(info.getDate());
     										innerLatch.countDown();
+    									}
     									public void onFailure(Throwable e) {
     										errors.offer(e);
     										innerLatch.countDown();
+    									}
     						});
     						waitLatch(innerLatch, errors, timeout);
     						outerLatch.countDown();
+    					}
     					public void onFailure(final Throwable e) {
     						log.error(ExceptionUtils.getStackTrace(e));
     						errors.offer(e);
     						outerLatch.countDown();
+    					}
     		});
+    	}
     	private void getAggregationHistory(final String dsId,
     			final CountDownLatch outerLatch,
     			final Queue<Throwable> errors,
     			final DatasourceResponse datasourceResponse) {
     		Futures.addCallback(
     				service.submit(() -> mongoLoggerClient.getAggregationHistory(dsId)),
     				new FutureCallback<List<AggregationInfo>>() {
     					public void onSuccess(List<AggregationInfo> info) {
     						setAggregationHistory(datasourceResponse, info);
     						outerLatch.countDown();
+    					}
     					public void onFailure(Throwable e) {
     						log.error(ExceptionUtils.getStackTrace(e));
     						errors.offer(e);
     						outerLatch.countDown();
+    					}
     		});
+    	}
     	private void setAggregationHistory(DatasourceResponse datasourceResponse, final List<AggregationInfo> info) {
     		datasourceResponse.setAggregationHistory(info);
     		if (!info.isEmpty()) {
     			datasourceResponse
     					.setLastCollection(info.stream().filter(a -> AggregationStage.COLLECT.equals(a.getAggregationStage())).findFirst().get())
     					.setLastTransformation(info.stream().filter(a -> AggregationStage.TRANSFORM.equals(a.getAggregationStage())).findFirst().get());
+    		}
+    	}
     	private void waitLatch(final CountDownLatch latch, final Queue<Throwable> errors, final int waitSeconds) {
     		try {
     			if (!latch.await(waitSeconds, TimeUnit.SECONDS)) {
     				errors.offer(new TimeoutException("Waiting for requests to complete has timed out."));
+    			}
     		} catch (final InterruptedException e) {
     			errors.offer(e);
+    		}
+    	}
+    }

     import eu.dnetlib.datasource.publisher.model.BrowseTerm;
     import eu.dnetlib.datasource.publisher.model.DatasourceResponse;
     import eu.dnetlib.datasource.publisher.model.Response;
     import eu.dnetlib.datasource.publisher.model.db.Api;
     import eu.dnetlib.datasource.publisher.model.db.Datasource;
     import eu.dnetlib.datasource.publisher.model.db.SearchInterfacesEntry;
     import io.swagger.annotations.*;
     import io.swagger.annotations.ApiOperation;
     import io.swagger.annotations.ApiResponse;
     import io.swagger.annotations.ApiResponses;
     @Api(value = "datasources", description = "the datasource manager API")
     @io.swagger.annotations.Api(value = "datasources", description = "the datasource manager API")
     public interface DatasourcesApi {
         @ApiOperation(value = "list identifiers", notes = "List the Datasource identifiers.", response = List.class)
         @ApiResponses(value = {
             @ApiResponse(code = 200, message = "OK", response = List.class),
             @ApiResponse(code = 200, message = "OK", response = String[].class),
             @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<String> listIds(int page, int size) throws ApiException;
         @ApiOperation(value = "get datasource by id", notes = "Returns Datasource details.", response = DatasourceResponse.class)
         @ApiResponses(value = {
             @ApiResponse(code = 200, message = "OK", response = DatasourceResponse.class),
             @ApiResponse(code = 200, message = "OK", response = DatasourceResponse[].class),
             @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         DatasourceResponse getDs(String id);
         @ApiOperation(value = "search datasources by name", notes = "Returns list of Datasource details.", response = DatasourceResponse.class)
         @ApiOperation(value = "search datasources by name", notes = "Returns list of Datasource details.", response = DatasourceResponse[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse.class),
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<DatasourceResponse> searchByName(String name, int page, int size);
         @ApiOperation(value = "search datasources by contact email", notes = "Returns list of Datasource details.", response = DatasourceResponse.class)
         @ApiOperation(value = "search datasources by contact email", notes = "Returns list of Datasource details.", response = DatasourceResponse[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse.class),
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<DatasourceResponse> searchByContactemail(String contactemail, int page, int size);
         @ApiOperation(value = "search datasources by country", notes = "Returns list of Datasource details.", response = DatasourceResponse.class)
         @ApiOperation(value = "search datasources by country", notes = "Returns list of Datasource details.", response = DatasourceResponse[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse.class),
                 @ApiResponse(code = 200, message = "OK", response = DatasourceResponse[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<DatasourceResponse> searchByCountry(String country, int page, int size);
         @ApiOperation(value = "search among datasource APIs", notes = "Returns Datasource Api details.", response = SearchInterfacesEntry.class)
         @ApiOperation(value = "search among datasource APIs", notes = "Returns Datasource Api details.", response = SearchInterfacesEntry[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = SearchInterfacesEntry.class),
                 @ApiResponse(code = 200, message = "OK", response = SearchInterfacesEntry[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<SearchInterfacesEntry> searchInterface(String field, String value);
         @ApiOperation(value = "terms and count for the given field", notes = "Returns the list of BrowseTerms.", response = BrowseTerm.class)
         @ApiOperation(value = "terms and count for the given field", notes = "Returns the list of BrowseTerms.", response = BrowseTerm[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = BrowseTerm.class),
                 @ApiResponse(code = 200, message = "OK", response = BrowseTerm[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<? extends BrowseTerm> browseField(String field) throws ApiException;
         @ApiOperation(value = "get the list of API for a given datasource", notes = "Returns the list of API for a given datasource.", httpMethod = "GET", response = Api[].class)
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK", response = Api[].class),
                 @ApiResponse(code = 500, message = "unexpected error", response = Response.class) })
         List<Api> getApi(String dsId) throws ApiException;
         @ApiOperation(value = "delete an API", notes = "delete an API", httpMethod = "DELETE")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void deleteApi(String apiId) throws ApiException;
         @ApiOperation(value = "adds an API to one Datasource", notes = "adds an API to one Datasource", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void addApi(Api api) throws ApiException;
         @ApiOperation(value = "set the managed status for a given datasource", notes = "set the managed status for a given datasource", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void setManaged(String id, boolean managed);
         @ApiOperation(value = "adds a new datasource", notes = "adds a new datasource", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void saveDatasource(Datasource datasource) throws ApiException;
         @ApiOperation(value = "updates a datasource official name", notes = "updates a datasource official name", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void updateOfficialname(String dsId, String officialname) throws ApiException;
         @ApiOperation(value = "updates a datasource english name", notes = "updates a datasource english name", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void updateEnglishname(String dsId, String english) throws ApiException;
         @ApiOperation(value = "updates a datasource latitude", notes = "updates a datasource latitude", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void updateLatitude(String dsId, Double latitude) throws ApiException;
         @ApiOperation(value = "updates a datasource longitude", notes = "updates a datasource longitude", httpMethod = "POST")
         @ApiResponses(value = {
                 @ApiResponse(code = 200, message = "OK"),
                 @ApiResponse(code = 500, message = "unexpected error") })
         void updateLongitude(String dsId, Double longitude) throws ApiException;
+    }

     import eu.dnetlib.common.rmi.DNetRestDocumentation;
     import eu.dnetlib.datasource.publisher.clients.ClientResponse;
     import eu.dnetlib.datasource.publisher.clients.DatasourceInfoRetriever;
     import eu.dnetlib.datasource.publisher.clients.DatasourceDao;
     import eu.dnetlib.datasource.publisher.model.BrowseTerm;
     import eu.dnetlib.datasource.publisher.model.DatasourceResponse;
     import eu.dnetlib.datasource.publisher.model.db.Api;
     import eu.dnetlib.datasource.publisher.model.db.Datasource;
     import eu.dnetlib.datasource.publisher.model.db.SearchInterfacesEntry;
     import org.apache.commons.lang.StringUtils;
     import org.apache.commons.logging.Log;
     import org.apache.commons.logging.LogFactory;
     import org.apache.http.HttpStatus;
-...
     	private static final Log log = LogFactory.getLog(DatasourcesApiController.class);
     	@Autowired
     	private DatasourceInfoRetriever dsInfoRetriever;
     	private DatasourceDao dsDao;
     	@Override
     	@RequestMapping(value = "/ds/list/{page}/{size}", produces = { "application/json" }, method = RequestMethod.GET)
         public List<String> listIds(@PathVariable int page, @PathVariable int size) throws ApiException {
     	    return dsInfoRetriever.listIds(new PageRequest(page, size));
     	    return dsDao.listIds(new PageRequest(page, size));
+        }
         @Override
-...
     		    log.debug(String.format("getDatasourceInfo(dsId = %s)", id));
+    	    }
     	    final ClientResponse clientResponse = dsInfoRetriever.getInfo(id);
     	    final ClientResponse clientResponse = dsDao.getInfo(id);
         	return clientResponse.getDatasourceResponse();
+        }
-...
     	@RequestMapping(value = "/ds/search/name/{page}/{size}", produces = { "application/json" }, method = RequestMethod.GET)
     	public List<DatasourceResponse> searchByName(
     			@RequestParam final String name, @PathVariable final int page, @PathVariable final int size) {
     		return dsInfoRetriever.searchByName(name, new PageRequest(page, size));
     		return dsDao.searchByName(name, new PageRequest(page, size));
+    	}
     	@Override
     	@RequestMapping(value = "/ds/search/email/{page}/{size}", produces = { "application/json" }, method = RequestMethod.GET)
     	public List<DatasourceResponse> searchByContactemail(
     			@RequestParam final String contactemail, @PathVariable final int page, @PathVariable final int size) {
     		return dsInfoRetriever.searchByContactemail(contactemail, new PageRequest(page, size));
     		return dsDao.searchByContactemail(contactemail, new PageRequest(page, size));
+    	}
     	@Override
     	@RequestMapping(value = "/ds/search/country/{page}/{size}", produces = { "application/json" }, method = RequestMethod.GET)
     	public List<DatasourceResponse> searchByCountry(
     			@RequestParam final String country, @PathVariable final int page, @PathVariable final int size) {
     		return dsInfoRetriever.searchByCountry(country, new PageRequest(page, size));
     		return dsDao.searchByCountry(country, new PageRequest(page, size));
+    	}
     	@Override
     	@RequestMapping(value = "/api/search/{field}", produces = { "application/json" }, method = RequestMethod.GET)
     	public List<SearchInterfacesEntry> searchInterface(@PathVariable final String field, @RequestParam final String value) {
     		return dsInfoRetriever.searchInterface(field, value);
     		return dsDao.searchInterface(field, value);
+    	}
     	@Override
-...
     	public List<? extends BrowseTerm> browseField(@PathVariable final String field) throws ApiException {
     		switch (field) {
     		case "country":
     			return dsInfoRetriever.browseCountries();
     			return dsDao.browseCountries();
     		case "typology":
     			return dsInfoRetriever.browseTypologies();
     			return dsDao.browseTypologies();
     		case "protocol":
     			return dsInfoRetriever.browseProtocols();
     			return dsDao.browseProtocols();
     		case "compatibility":
     			return dsInfoRetriever.browseCompatibility();
     			return dsDao.browseCompatibility();
     		case "activation":
     			return dsInfoRetriever.browseActivation();
     			return dsDao.browseActivation();
     		default:
     			throw new ApiException(HttpStatus.SC_BAD_REQUEST, String.format("unsupported browse field '%s'", field));
+    		}
+    	}
     	@Override
     	@RequestMapping(value = "/ds/api/{dsId}", produces = { "application/json" }, method = RequestMethod.GET)
     	public List<Api> getApi(@PathVariable final String dsId) throws ApiException {
     		return dsDao.getApi(dsId);
+    	}
     	@Override
     	@RequestMapping(value = "/ds/api/{dsId}", method = RequestMethod.DELETE)
     	public void deleteApi(@PathVariable final String apiId) throws ApiException {
     		dsDao.deleteApi(apiId);
+    	}
     	@Override
     	@RequestMapping(value = "/ds/api/add", method = RequestMethod.POST)
     	public void addApi(@RequestParam final Api api) throws ApiException {
     		if (StringUtils.isBlank(api.getDatasource())) {
     			throw new ApiException(HttpStatus.SC_BAD_REQUEST, "missing datasource id");
+    		}
     		dsDao.addApi(api);
+    	}
     	@Override
     	@RequestMapping(value = "/ds/manage", method = RequestMethod.POST)
     	public void setManaged(@RequestParam final String id, @RequestParam final boolean managed) {
     		dsInfoRetriever.setManaged(id, managed);
     		dsDao.setManaged(id, managed);
+    	}
     	@Override
     	@RequestMapping(value = "/ds/add", method = RequestMethod.POST)
     	public void saveDatasource(@RequestBody final Datasource datasource) throws ApiException {
     		if (dsDao.exist(datasource)) { //TODO further check that the DS doesn't have any API

Project

General

Profile

D-Net

Revision 47676

Added by Claudio Atzori almost 7 years ago