D-Net

package eu.dnetlib.services;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import org.antlr.stringtemplate.StringTemplate;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

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

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

import com.google.common.collect.Sets;

import eu.dnetlib.clients.ISLookUpClient;

import eu.dnetlib.clients.ISRegistryClient;

import eu.dnetlib.enabling.annotations.DnetServiceType;

import eu.dnetlib.exceptions.ISLookUpException;

@Component

public class ServiceRegistrationManager {

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

	@Autowired

	private ISLookUpClient isLookup;

	@Autowired

	private ISRegistryClient isRegistry;

	private boolean disabled = false;

	@Autowired(required = false)

	private List<BaseService> services = new ArrayList<>();

	@Scheduled(fixedDelay = 20000)

	public void registerAllServices() throws Exception {

		if (disabled) { return; }

		log.info("registering services...");

		disabled = true;

		final Set<String> schemas = Sets.newHashSet(isLookup.listSchemas());

		for (final BaseService service : services) {

			if (!schemas.contains(service.getServiceType())) {

				registerSchema(service.getServiceType());

			}

			if (!isAlreadyRegistered(service)) {

				registerService(service);

			}

		}

		log.info("...all services registered");

	}

	private boolean isAlreadyRegistered(final BaseService service) throws ISLookUpException {

		final String query = "for $x in collection('/db/DRIVER/DnetService') "

				+ "where $x//baseUrl='" + service.getBaseUrl() + "' "

				+ "and $x//type/@value = '" + service.getServiceType() + "' "

				+ "return $x//id/text()";

		final List<String> profIds = isLookup.find(query);

		if (profIds.isEmpty()) {

			log.debug("there is no service registered for service: " + service.getServiceType());

			return false;

		} else {

			service.setProfileId(profIds.get(0));

			return true;

		}

	}

	private void registerService(final BaseService service) throws Exception {

		final DnetServiceType type = service.getServiceType();

		final String st = IOUtils.toString(getClass().getResourceAsStream("ServiceProfileTemplate.st"));

		final StringTemplate templ = new StringTemplate(st);

		templ.setAttribute("resourceType", type);

		templ.setAttribute("baseUrl", service.getBaseUrl());

		templ.setAttribute("properties", new HashMap<>());

		final String profId = isRegistry.register(templ.toString());

		log.info("  new service: " + profId);

		service.setProfileId(profId);

	}

	private void registerSchema(final DnetServiceType type) throws Exception {

		final InputStream schemaStream = getClass().getResourceAsStream("ServiceProfileSchemaTemplate.st");

		if (schemaStream == null) { throw new IllegalStateException("cannot find service profile schema template"); }

		final StringTemplate schema = new StringTemplate(IOUtils.toString(schemaStream));

		schema.setAttribute("resourceType", type);

		isRegistry.registerSchema(type.toString(), schema.toString());

		log.info("  new schema  : " + type);

	}

	public boolean isDisabled() {

		return disabled;

	}

}