D-Net

import eu.dnetlib.services.ApiDocUtils;

		return ApiDocUtils.newSwaggerDocket();

		<version>1.4.4.RELEASE</version>

import org.springframework.context.annotation.Bean;

import eu.dnetlib.services.ApiDocUtils;

import springfox.documentation.spring.web.plugins.Docket;

	@Bean

	public Docket api() {

		return ApiDocUtils.newSwaggerDocket();

	}

package eu.dnetlib.msro.controllers;

import java.util.List;

import java.util.stream.Collectors;

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

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

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

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

import eu.dnetlib.msro.workers.aggregation.collect.CollectorPluginEnumerator;

import eu.dnetlib.msro.workers.aggregation.collect.plugins.CollectorPlugin;

@RestController

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

public class CollectorController {

	@Autowired

	private CollectorPluginEnumerator plugins;

	@RequestMapping("plugins")

	private List<String> plugins() {

		return plugins.getAll().stream().map(CollectorPlugin::getProtocol).sorted().collect(Collectors.toList());

	}

}

package eu.dnetlib.msro.controllers;

import java.util.Arrays;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

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

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

import eu.dnetlib.enabling.annotations.DnetService;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.msro.annotations.ProcessNode;

import eu.dnetlib.msro.workers.aggregation.collect.plugins.CollectorPlugin;

import eu.dnetlib.msro.workers.aggregation.collect.plugins.DnetCollectorParam;

import eu.dnetlib.msro.workers.aggregation.collect.plugins.DnetCollectorPlugin;

import eu.dnetlib.msro.workers.aggregation.collect.plugins.ProtocolParameterType;

import eu.dnetlib.msro.workflows.nodes.AbstractProcessNode;

import eu.dnetlib.services.BaseService;

@RestController

@RequestMapping("/worker")

@DnetService(DnetServiceType.msroWorker)

public class MsroWorkerController extends BaseService implements ApplicationContextAware {

	private ApplicationContext applicationContext;

	@Override

	public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {

		this.applicationContext = applicationContext;

	}

	@Override

	public List<Element> geXmlProfileSections() {

		final Element nodes = DocumentHelper.createElement("WORKFLOW_NODES");

		final Element collPlugins = DocumentHelper.createElement("COLLECTOR_PLUGINS");

		applicationContext.getBeansOfType(AbstractProcessNode.class)

				.values()

				.stream()

				.map(Object::getClass)

				.filter(cl -> cl.isAnnotationPresent(ProcessNode.class))

				.forEach(cl -> {

					final Element n = nodes.addElement("NODE");

					n.addAttribute("type", cl.getAnnotation(ProcessNode.class).value());

					n.addAttribute("class", cl.getName());

				});

		applicationContext.getBeansOfType(CollectorPlugin.class)

				.values()

				.stream()

				.map(Object::getClass)

				.filter(cl -> cl.isAnnotationPresent(DnetCollectorPlugin.class))

				.map(cl -> cl.getAnnotation(DnetCollectorPlugin.class))

				.forEach(ann -> {

					final Element plugin = collPlugins.addElement("PLUGIN");

					plugin.addAttribute("protocol", ann.value());

					for (final DnetCollectorParam ap : ann.parameters()) {

						final Element p = plugin.addElement("PARAM");

						p.addAttribute("name", ap.value());

						p.addAttribute("type", ap.type().toString());

						p.addAttribute("optional", Boolean.toString(ap.optional()));

						if (StringUtils.isNotBlank(ap.regex()) && (ap.type() == ProtocolParameterType.TEXT)) {

							p.addAttribute("regex", ap.regex());

						}

					}

				});

		return Arrays.asList(nodes, collPlugins);

	}

}

import springfox.documentation.swagger2.annotations.EnableSwagger2;

@EnableSwagger2

import org.springframework.stereotype.Component;

@Component

package eu.dnetlib.services;

import springfox.documentation.builders.RequestHandlerSelectors;

import springfox.documentation.spi.DocumentationType;

import springfox.documentation.spring.web.plugins.Docket;

public class ApiDocUtils {

	public static Docket newSwaggerDocket() {

		return new Docket(DocumentationType.SWAGGER_2)

				.select()

				.apis(RequestHandlerSelectors.any())

				.paths(p -> !(p.equals("/") || p.startsWith("/error")))

				.build();

	}

}

package eu.dnetlib.services;

import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;

import org.springframework.stereotype.Controller;

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

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

import springfox.documentation.spring.web.plugins.Docket;

@Controller

@ConditionalOnBean(Docket.class)

public class ApiDocController {

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

	public String redirect() {

		return "redirect:swagger-ui.html";

	}

}

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

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

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

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

			<scope>provided</scope>

			<scope>provided</scope>

			<scope>provided</scope>

			<groupId>org.springframework.boot</groupId>

			<artifactId>spring-boot-autoconfigure</artifactId>

			<version>1.4.4.RELEASE</version>

			<scope>provided</scope>

		</dependency>

		<dependency>