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

     package eu.dnetlib.openaire.exporter.datasource.clients;
     import java.io.IOException;
     import java.sql.Connection;
     import java.sql.PreparedStatement;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.util.List;
     import com.google.common.collect.Lists;
     import eu.dnetlib.openaire.exporter.datasource.ApiException;
     import org.antlr.stringtemplate.StringTemplate;
     import org.apache.commons.dbcp2.BasicDataSource;
     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.beans.factory.annotation.Value;
     import org.springframework.core.io.ClassPathResource;
     import org.springframework.core.io.Resource;
     import org.springframework.http.HttpStatus;
     import org.springframework.stereotype.Component;
     /**
      * Created by claudio on 25/11/2016.
      */
     @Component
     public class JdbcDatasourceDao {
     	private static final Log log = LogFactory.getLog(JdbcDatasourceDao.class);
     	@Value("${openaire.datasource.publisher.getsingle.sql}")
     	private ClassPathResource datasourceDetailsSql;
     	@Autowired
     	private BasicDataSource dsDataSource;
     	public List<String> listIds() throws ApiException {
     		final List<String> res = Lists.newArrayList();
     		try {
     			final String sql = "SELECT id FROM dashboard_ds";
     			try (final Connection con = getConn(); final PreparedStatement stm = getStm(sql, con); final ResultSet rs = stm.executeQuery()) {
     				while (rs.next()) {
     					res.add(rs.getString("id"));
+    				}
+    			}
     		} catch(SQLException e) {
     			throw new ApiException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "Error querying datasource ids from database", e);
+    		}
     		return res;
+    	}
     	private Connection getConn() throws SQLException {
     		final Connection conn = dsDataSource.getConnection();
     		conn.setAutoCommit(false);
     		return conn;
+    	}
     	private PreparedStatement getStm(final String sql, final Connection con) throws SQLException {
     		final PreparedStatement stm = con.prepareStatement(sql);
     		stm.setFetchSize(10);
     		return stm;
+    	}
     	protected String obtainQuery(final Resource template, final String id) throws IllegalArgumentException, IOException {
     		final StringTemplate st = new StringTemplate(IOUtils.toString(template.getInputStream()));
     		st.setAttribute("id", id);
     		final String sql = st.toString();
     		log.debug("Generated query: " + sql);
     		return sql;
+    	}
+    }

     SELECT
     	code,
     	acronym,
     	title,
     	call_identifier,
     	startdate,
     	enddate,
     	oa_mandate_for_publications,
     	oa_mandate_for_datasets,
     	description,
     	legalname,
     	country,
     	role,
     	firstname,
     	secondnames,
     	email
     FROM projects_tsv
     WHERE fundingpathid like '$fundingprefix$%'$filters.keys:{k| AND $k$=$filters.(k)$}$
     ORDER BY acronym

     import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
     import static org.junit.Assert.assertEquals;
     @SpringBootTest
     @RunWith(SpringJUnit4ClassRunner.class)
     //@ContextConfiguration(classes={TestConfiguration.class})
     @SpringBootTest
     public class ProjectsControllerTest {
     	private static final Log log = LogFactory.getLog(ProjectsControllerTest.class);
-...
     		controller = new ProjectsController();
     		Resource template = new ClassPathResource(queryTemplate);
     		controller.setProjectsFundingQueryTemplate(template);
     		//TODO reimplement bean injection for testing
     		//controller.setProjectsFundingQueryTemplate(template);
     		params = new ProjectQueryParams();
+    	}

     package eu.dnetlib.swagger.configuration;
     import eu.dnetlib.OpenaireExporterConfig;
     import eu.dnetlib.OpenaireExporterConfig.Swagger;
     import eu.dnetlib.common.rmi.DNetRestDocumentation;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;
-...
     @EnableSwagger2
     public class SwaggerDocumentationConfig {
         @Value("${api.rest.contact.name}")
         private String contactName;
         @Value("${api.rest.contact.url}")
         private String contactUrl;
         @Value("${api.rest.contact.email}")
         private String contactEmail;
     	@Value("${api.rest.title}")
     	private String title;
     	@Value("${api.rest.description}")
     	private String description;
     	@Value("${api.rest.license}")
     	private String license;
     	@Value("${api.rest.license.url}")
     	private String licenseUrl;
     	@Autowired
     	private OpenaireExporterConfig config;
         @Bean
         public Docket customImplementation() {
-...
+        }
     	private ApiInfo apiInfo() {
     		final Swagger swag = config.getSwagger();
     		return new ApiInfoBuilder()
     				.title(title)
     				.description(description)
     				.license(license)
     				.licenseUrl(licenseUrl)
     				.title(swag.getApiTitle())
     				.description(swag.getApiDescription())
     				.license(swag.getApiLicense())
     				.licenseUrl(swag.getApiLicenseUrl())
     				.termsOfServiceUrl("")
     				.version("1.0.0")
     				.contact(new Contact(contactName, contactUrl, contactEmail))
     				.contact(new Contact(
     						swag.getApiContactName(),
     						swag.getApiContactUrl(),
     						swag.getApiContactEmail()))
     				.build();
+    	}

     package eu.dnetlib;
     import com.mongodb.MongoClient;
     import com.mongodb.MongoClientOptions;
     import com.mongodb.ServerAddress;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import org.apache.commons.dbcp2.BasicDataSource;
     import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;
     import org.springframework.boot.context.properties.ConfigurationProperties;
     import org.springframework.core.io.ClassPathResource;
     import org.springframework.core.io.Resource;
     import org.springframework.stereotype.Component;
     /**
      * Created by Alessia Bardi on 31/03/17.
+     *
      * @author Alessia Bardi
      */
     @Configuration
     @Component
     @ConfigurationProperties(prefix = "openaire.exporter")
     public class OpenaireExporterConfig {
     	// POSTGRES
     	@Value("${spring.datasource.driverClassName}")
     	private String driverClassName;
     	@Value("${openaire.exporter.jdbc.url}")
     	private String jdbcUrl;
     	@Value("${openaire.exporter.jdbc.user}")
     	private String jdbcUser;
     	@Value("${openaire.exporter.jdbc.pwd}")
     	private String jdbcPwd;
     	@Value("${openaire.exporter.jdbc.minIdle}")
     	private int jdbcMinIdle;
     	@Value("${openaire.exporter.jdbc.maxIdle}")
     	private int jdbcMaxidle;
     	// ISLOOKUP
     	private ClassPathResource findSolrIndexUrl;
     	private ClassPathResource findIndexDsInfo;
     	private String isLookupUrl;
     	private int requestWorkers = 100;
     	private int requestTimeout = 10;
     	// MONGODB
     	@Value("${openaire.datasource.publisher.mongodb.host}")
     	private String mongodbHost;
     	@Value("${openaire.datasource.publisher.mongodb.port}")
     	private int mongodbPort;
     	@Value("${openaire.datasource.publisher.mongodb.connectionsPerHost}")
     	private int connectionsPerHost;
     	private Datasource datasource;
     	private Project project;
     	private Jdbc jdbc;
     	private Swagger swagger;
     	@Value("${services.is.lookup.url}")
     	private String isLookupUrl;
     	public static class Datasource {
     		// MONGODB
     		private String mongoHost;
     		private int mongoPort;
     		private String mongoCollectionName;
     		private String mongoDbName;
     		private int mongoConnectionsPerHost;
     		private int mongoQueryLimit;
     	@Bean
     	public ISLookUpService getLookUpService() {
     		final JaxWsProxyFactoryBean jaxWsProxyFactory = new JaxWsProxyFactoryBean();
     		jaxWsProxyFactory.setServiceClass(ISLookUpService.class);
     		jaxWsProxyFactory.setAddress(isLookupUrl);
     		return (ISLookUpService) jaxWsProxyFactory.create();
     		public String getMongoHost() {
     			return mongoHost;
+    		}
     		public void setMongoHost(final String mongoHost) {
     			this.mongoHost = mongoHost;
+    		}
     		public int getMongoPort() {
     			return mongoPort;
+    		}
     		public void setMongoPort(final int mongoPort) {
     			this.mongoPort = mongoPort;
+    		}
     		public String getMongoCollectionName() {
     			return mongoCollectionName;
+    		}
     		public void setMongoCollectionName(final String mongoCollectionName) {
     			this.mongoCollectionName = mongoCollectionName;
+    		}
     		public String getMongoDbName() {
     			return mongoDbName;
+    		}
     		public void setMongoDbName(final String mongoDbName) {
     			this.mongoDbName = mongoDbName;
+    		}
     		public int getMongoConnectionsPerHost() {
     			return mongoConnectionsPerHost;
+    		}
     		public void setMongoConnectionsPerHost(final int mongoConnectionsPerHost) {
     			this.mongoConnectionsPerHost = mongoConnectionsPerHost;
+    		}
     		public int getMongoQueryLimit() {
     			return mongoQueryLimit;
+    		}
     		public void setMongoQueryLimit(final int mongoQueryLimit) {
     			this.mongoQueryLimit = mongoQueryLimit;
+    		}
+    	}
     	@Bean
     	public BasicDataSource getProjectDataSource() {
     		return getDatasource(driverClassName, jdbcUrl, jdbcUser, jdbcPwd, jdbcMinIdle, jdbcMaxidle);
     	public static class Project {
     		private int gzipFlushSize;
     		private String tsvFields;
     		private Resource projectsFundingQueryTemplate;
     		private Resource dspaceTemplate;
     		private Resource dspaceHeadTemplate;
     		private Resource dspaceTailTemplate;
     		private Resource eprintsTemplate;
     		public int getGzipFlushSize() {
     			return gzipFlushSize;
+    		}
     		public void setGzipFlushSize(final int gzipFlushSize) {
     			this.gzipFlushSize = gzipFlushSize;
+    		}
     		public String getTsvFields() {
     			return tsvFields;
+    		}
     		public void setTsvFields(final String tsvFields) {
     			this.tsvFields = tsvFields;
+    		}
     		public Resource getProjectsFundingQueryTemplate() {
     			return projectsFundingQueryTemplate;
+    		}
     		public void setProjectsFundingQueryTemplate(final Resource projectsFundingQueryTemplate) {
     			this.projectsFundingQueryTemplate = projectsFundingQueryTemplate;
+    		}
     		public Resource getDspaceTemplate() {
     			return dspaceTemplate;
+    		}
     		public void setDspaceTemplate(final Resource dspaceTemplate) {
     			this.dspaceTemplate = dspaceTemplate;
+    		}
     		public Resource getDspaceHeadTemplate() {
     			return dspaceHeadTemplate;
+    		}
     		public void setDspaceHeadTemplate(final Resource dspaceHeadTemplate) {
     			this.dspaceHeadTemplate = dspaceHeadTemplate;
+    		}
     		public Resource getDspaceTailTemplate() {
     			return dspaceTailTemplate;
+    		}
     		public void setDspaceTailTemplate(final Resource dspaceTailTemplate) {
     			this.dspaceTailTemplate = dspaceTailTemplate;
+    		}
     		public Resource getEprintsTemplate() {
     			return eprintsTemplate;
+    		}
     		public void setEprintsTemplate(final Resource eprintsTemplate) {
     			this.eprintsTemplate = eprintsTemplate;
+    		}
+    	}
     	private BasicDataSource getDatasource(String driverClassName, String jdbcUrl, String jdbcUser, String jdbcPwd, int jdbcMinIdle, int jdbcMaxIdle) {
     		BasicDataSource d =  new BasicDataSource();
     		d.setDriverClassName(driverClassName);
     		d.setUrl(jdbcUrl);
     		d.setUsername(jdbcUser);
     		d.setPassword(jdbcPwd);
     		d.setMinIdle(jdbcMinIdle);
     		d.setMaxIdle(jdbcMaxIdle);
     		return d;
     	public static class Jdbc {
     		// JDBC
     		@Value("${spring.datasource.driverClassName}")
     		private String driverClassName;
     		private String url;
     		private String user;
     		private String pwd;
     		private int minIdle;
     		private int maxidle;
     		private int maxRows;
     		public String getDriverClassName() {
     			return driverClassName;
+    		}
     		public String getUrl() {
     			return url;
+    		}
     		public void setUrl(final String url) {
     			this.url = url;
+    		}
     		public String getUser() {
     			return user;
+    		}
     		public void setUser(final String user) {
     			this.user = user;
+    		}
     		public String getPwd() {
     			return pwd;
+    		}
     		public void setPwd(final String pwd) {
     			this.pwd = pwd;
+    		}
     		public int getMinIdle() {
     			return minIdle;
+    		}
     		public void setMinIdle(final int minIdle) {
     			this.minIdle = minIdle;
+    		}
     		public int getMaxidle() {
     			return maxidle;
+    		}
     		public void setMaxidle(final int maxidle) {
     			this.maxidle = maxidle;
+    		}
     		public int getMaxRows() {
     			return maxRows;
+    		}
     		public void setMaxRows(final int maxRows) {
     			this.maxRows = maxRows;
+    		}
+    	}
     	@Bean
     	public MongoClient getMongoClient() {
     		return new MongoClient(
     				new ServerAddress(mongodbHost, mongodbPort),
     				MongoClientOptions.builder().connectionsPerHost(connectionsPerHost).build());
     	public static class Swagger {
     		private String apiTitle;
     		private String apiDescription;
     		private String apiLicense;
     		private String apiLicenseUrl;
     		private String apiContactName;
     		private String apiContactUrl;
     		private String apiContactEmail;
     		public String getApiTitle() {
     			return apiTitle;
+    		}
     		public void setApiTitle(final String apiTitle) {
     			this.apiTitle = apiTitle;
+    		}
     		public String getApiDescription() {
     			return apiDescription;
+    		}
     		public void setApiDescription(final String apiDescription) {
     			this.apiDescription = apiDescription;
+    		}
     		public String getApiLicense() {
     			return apiLicense;
+    		}
     		public void setApiLicense(final String apiLicense) {
     			this.apiLicense = apiLicense;
+    		}
     		public String getApiLicenseUrl() {
     			return apiLicenseUrl;
+    		}
     		public void setApiLicenseUrl(final String apiLicenseUrl) {
     			this.apiLicenseUrl = apiLicenseUrl;
+    		}
     		public String getApiContactName() {
     			return apiContactName;
+    		}
     		public void setApiContactName(final String apiContactName) {
     			this.apiContactName = apiContactName;
+    		}
     		public String getApiContactUrl() {
     			return apiContactUrl;
+    		}
     		public void setApiContactUrl(final String apiContactUrl) {
     			this.apiContactUrl = apiContactUrl;
+    		}
     		public String getApiContactEmail() {
     			return apiContactEmail;
+    		}
     		public void setApiContactEmail(final String apiContactEmail) {
     			this.apiContactEmail = apiContactEmail;
+    		}
+    	}
     	public ClassPathResource getFindSolrIndexUrl() {
     		return findSolrIndexUrl;
+    	}
     	public void setFindSolrIndexUrl(final ClassPathResource findSolrIndexUrl) {
     		this.findSolrIndexUrl = findSolrIndexUrl;
+    	}
     	public ClassPathResource getFindIndexDsInfo() {
     		return findIndexDsInfo;
+    	}
     	public void setFindIndexDsInfo(final ClassPathResource findIndexDsInfo) {
     		this.findIndexDsInfo = findIndexDsInfo;
+    	}
     	public String getIsLookupUrl() {
     		return isLookupUrl;
+    	}
     	public void setIsLookupUrl(final String isLookupUrl) {
     		this.isLookupUrl = isLookupUrl;
+    	}
     	public int getRequestWorkers() {
     		return requestWorkers;
+    	}
     	public void setRequestWorkers(final int requestWorkers) {
     		this.requestWorkers = requestWorkers;
+    	}
     	public int getRequestTimeout() {
     		return requestTimeout;
+    	}
     	public void setRequestTimeout(final int requestTimeout) {
     		this.requestTimeout = requestTimeout;
+    	}
     	public Datasource getDatasource() {
     		return datasource;
+    	}
     	public void setDatasource(final Datasource datasource) {
     		this.datasource = datasource;
+    	}
     	public Project getProject() {
     		return project;
+    	}
     	public void setProject(final Project project) {
     		this.project = project;
+    	}
     	public Jdbc getJdbc() {
     		return jdbc;
+    	}
     	public void setJdbc(final Jdbc jdbc) {
     		this.jdbc = jdbc;
+    	}
     	public Swagger getSwagger() {
     		return swagger;
+    	}
     	public void setSwagger(final Swagger swagger) {
     		this.swagger = swagger;
+    	}
+    }

     package eu.dnetlib.openaire.exporter.model.project;
     import java.sql.Date;
     import java.util.ArrayList;
     import javax.persistence.Entity;
     import javax.persistence.Id;
     import javax.persistence.Table;
     import com.fasterxml.jackson.annotation.JsonIgnore;
     import com.google.common.base.Splitter;
     import com.google.common.collect.Lists;
     import io.swagger.annotations.ApiModel;
     import org.apache.commons.lang3.StringUtils;
     /**
      * Created by claudio on 20/09/16.
      */
     @Entity
     @Table(name = "projects_api")
     @ApiModel(value = "Project api model", description = "Project api model used by DSpace and Eprints exporter")
     public class ProjectApi {
     	public static final String INFO_EU_REPO_GRANT_AGREEMENT = "info:eu-repo/grantAgreement/";
     	@Id
     	@JsonIgnore
     	private int id;
     	private String code;
     	private String acronym;
     	private String title;
     	private String funder;
     	private String jurisdiction;
     	private Date startdate;
     	private Date enddate;
     	private String fundingpathid;
     	public ProjectApi() { }
     	public String getIdnamespace() {
     		String res = INFO_EU_REPO_GRANT_AGREEMENT + getFunder()+"/";
     		final String fundingProgram = asFundingProgram(getFundingpathid());
     		if (StringUtils.isNotBlank(fundingProgram)) {
     			res += fundingProgram;
+    		}
     		res += "/" + escapeCode(getCode());
     		if (StringUtils.isNotBlank(getJurisdiction())) {
     			res += "/" + getJurisdiction();
+    		}
     		return res;
+    	}
     	public String getListLabel() {
     		return String.format("for:value:component:_%s_project_id", asFunder(getFunder()));
+    	}
     	private String asFunder(final String legalshortname) {
     		switch (legalshortname.toLowerCase()) {
     		case "ec":
     			return asFundingProgram(getFundingpathid()).toLowerCase();
     		default:
     			return legalshortname.toLowerCase();
+    		}
+    	}
     	private String escapeCode(final String code) {
     		return replaceSlash(code);
+    	}
     	private String asFundingProgram(final String fundingpathid) {
     		final ArrayList<String> strings = Lists.newArrayList(Splitter.on("::").split(fundingpathid));
     		if(strings.size() <= 1) throw new IllegalStateException("Unexpected funding id: "+fundingpathid);
     		if(strings.size() == 2) return "";
     		else return replaceSlash(strings.get(2));
+    	}
     	private String replaceSlash(final String s) {
     		return s.replaceAll("/", "%2F");
+    	}
     	public int getId() {
     		return id;
+    	}
     	public void setId(final int id) {
     		this.id = id;
+    	}
     	public String getCode() {
     		return code;
+    	}
     	public void setCode(final String code) {
     		this.code = code;
+    	}
     	public String getAcronym() {
     		return acronym;
+    	}
     	public void setAcronym(final String acronym) {
     		this.acronym = acronym;
+    	}
     	public String getTitle() {
     		return title;
+    	}
     	public void setTitle(final String title) {
     		this.title = title;
+    	}
     	public String getFunder() {
     		return funder;
+    	}
     	public void setFunder(final String funder) {
     		this.funder = funder;
+    	}
     	public String getJurisdiction() {
     		return jurisdiction;
+    	}
     	public void setJurisdiction(final String jurisdiction) {
     		this.jurisdiction = jurisdiction;
+    	}
     	public Date getStartdate() {
     		return startdate;
+    	}
     	public void setStartdate(final Date startdate) {
     		this.startdate = startdate;
+    	}
     	public Date getEnddate() {
     		return enddate;
+    	}
     	public void setEnddate(final Date enddate) {
     		this.enddate = enddate;
+    	}
     	public String getFundingpathid() {
     		return fundingpathid;
+    	}
     	public void setFundingpathid(final String fundingpathid) {
     		this.fundingpathid = fundingpathid;
+    	}
+    }

     package eu.dnetlib.openaire.exporter.project.repository;
     import eu.dnetlib.openaire.exporter.model.project.ProjectApi;
     import eu.dnetlib.openaire.exporter.model.project.ProjectTsv;
     import org.springframework.data.repository.PagingAndSortingRepository;
     import org.springframework.stereotype.Repository;
     /**
      * Created by claudio on 06/07/2017.
      */
     @Repository
     public interface ProjectApiRepository extends PagingAndSortingRepository<ProjectApi, Integer> {
     	Iterable<ProjectTsv> findByFundingpathidStartingWith(String fundingpathid);
+    }

     package eu.dnetlib.openaire.exporter.project;
     import java.io.BufferedOutputStream;
     import java.io.IOException;
     import java.io.OutputStream;
     import java.nio.charset.Charset;
     import java.sql.*;
     import java.sql.Connection;
     import java.sql.PreparedStatement;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.time.Duration;
     import java.time.LocalDateTime;
     import java.util.Arrays;
     import java.util.List;
     import java.util.concurrent.ScheduledThreadPoolExecutor;
     import java.util.concurrent.atomic.AtomicInteger;
     import java.util.zip.GZIPOutputStream;
     import java.util.zip.ZipEntry;
     import java.util.zip.ZipOutputStream;
     import com.google.common.base.Function;
     import javax.annotation.PostConstruct;
     import com.google.common.base.Joiner;
     import com.google.common.base.Splitter;
     import com.google.common.collect.Iterables;
     import com.google.common.collect.Lists;
     import com.google.common.util.concurrent.ListeningExecutorService;
     import com.google.common.util.concurrent.MoreExecutors;
     import com.google.common.util.concurrent.ThreadFactoryBuilder;
     import eu.dnetlib.OpenaireExporterConfig;
     import eu.dnetlib.openaire.exporter.datasource.ApiException;
     import eu.dnetlib.openaire.exporter.model.project.Project;
     import eu.dnetlib.openaire.exporter.model.project.ProjectTsv;
     import eu.dnetlib.openaire.exporter.project.repository.ProjectDetailsRepository;
     import eu.dnetlib.openaire.exporter.project.repository.ProjectTsvRepository;
     import org.antlr.stringtemplate.StringTemplate;
     import org.apache.commons.dbcp2.BasicDataSource;
     import org.apache.commons.lang3.StringUtils;
     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.stereotype.Component;
     /**
-...
     public class JdbcApiDao {
     	public static final Charset UTF8 = Charset.forName("UTF-8");
     	private static final Log log = LogFactory.getLog(JdbcApiDao.class);
     	@Value("${openaire.exporter.jdbc.maxrows}")
     	private int maxRows;
     	@Value("${openaire.project.exporter.projectdetails.flushsize}")
     	private int gzipFlushSize;
     	@Autowired
     	private OpenaireExporterConfig config;
     	@Value("${openaire.project.exporter.projects2tsv.fields}")
     	private String tsvFields;
     	@Autowired
     	private BasicDataSource projectApiDataSource;
     	public void streamProjects(final String sql, final OutputStream out,
     			final String head, final StringTemplate projectTemplate, final String tail,
     			final ValueCleaner cleaner) throws IOException, SQLException {
     	@Autowired
     	private ProjectDetailsRepository projectDetailsRepository;
     		if (log.isDebugEnabled()) {
     			log.debug("Thread " + Thread.currentThread().getId() + " begin");
+    		}
     		final LocalDateTime start = LocalDateTime.now();
     	@Autowired
     	private ProjectTsvRepository projectTsvRepository;
     		if (StringUtils.isNotBlank(head)) {
     			out.write(head.getBytes(UTF8));
+    		}
     	private ListeningExecutorService service;
     		try(final Connection con = getConn(); final PreparedStatement stm = getStm(sql, con); final ResultSet rs = stm.executeQuery()) {
     			while(rs.next()){
     				final Project p = new Project()
     						.setFunder(cleaner.clean(rs.getString("funder")))
     						.setJurisdiction(cleaner.clean(rs.getString("jurisdiction")))
     						.setFundingpathid(cleaner.clean(rs.getString("fundingpathid")))
     						.setAcronym(cleaner.clean(rs.getString("acronym")))
     						.setTitle(cleaner.clean(rs.getString("title")))
     						.setCode(cleaner.clean(rs.getString("code")))
     						.setStartdate(cleaner.clean(rs.getString("startdate")))
     						.setEnddate(cleaner.clean(rs.getString("enddate")));
     	@PostConstruct
     	public void init() {
     		service = MoreExecutors.listeningDecorator(
     				new ScheduledThreadPoolExecutor(config.getRequestWorkers(),
     						new ThreadFactoryBuilder().setNameFormat("project-exporter-dao-%d").build()));
+    	}
     				projectTemplate.reset();
     				projectTemplate.setAttribute("p", p);
     				out.write(projectTemplate.toString().getBytes(UTF8));
     	public void processProjectDetails(final OutputStream outputStream, String format, Boolean compress) throws IOException {
     		service.execute(() -> {
     			try {
     				final OutputStream out = getOutputStream(outputStream, compress);
     				try {
     					final AtomicInteger i = new AtomicInteger(0);
     					projectDetailsRepository.findAll().forEach(p -> {
     							try {
     								switch (format) {
     								case "csv":
     									out.write(p.asCSV().getBytes(UTF8));
     									break;
     								case "json":
     									out.write(p.asJson().getBytes(UTF8));
     									break;
+    								}
     								i.incrementAndGet();
     								if (i.intValue() % config.getProject().getGzipFlushSize() == 0) {
     									log.debug("flushing output stream");
     									out.flush();
+    								}
     							} catch (IOException e) {
     								throw new RuntimeException(e);
+    							}
+    						}
     					);
     				} finally {
     					if (out instanceof GZIPOutputStream) {
     						((GZIPOutputStream) out).finish();
+    					}
     					out.close();
+    				}
     			} catch (IOException e) {
     				throw new RuntimeException(e);
+    			}
     			if (StringUtils.isNotBlank(tail)) {
     				out.write(tail.getBytes(UTF8));
+    			}
     			final LocalDateTime end = LocalDateTime.now();
     			if (log.isDebugEnabled()) {
     				log.debug("Thread " + Thread.currentThread().getId() + " ends, took: " + Duration.between(start, end));
+    			}
     		} finally {
     			out.close();
+    		}
     		});
+    	}
     	public void streamProjectsTSV(final String sql, final ZipOutputStream out) throws IOException, SQLException {
     		if (log.isDebugEnabled()) {
     			log.debug("Thread " + Thread.currentThread().getId() + " begin");
     	private OutputStream getOutputStream(final OutputStream outputStream, final Boolean compress) throws IOException {
     		if (compress != null && compress) {
     			return new GZIPOutputStream(outputStream);
+    		}
     		final LocalDateTime start = LocalDateTime.now();
     		final List<String> fields = Lists.newArrayList(Splitter.on(",").omitEmptyStrings().trimResults().split(tsvFields));
     		writeCSVLine(out, fields);
     		try(final Connection con = getConn(); final PreparedStatement stm = getStm(sql, con); final ResultSet rs = stm.executeQuery()) {
     			while(rs.next()) {
     				final Project p = new Project()
     						.setCode(rs.getString("code"))
     						.setAcronym(rs.getString("acronym"))
     						.setTitle(rs.getString("title"))
     						.setCallIdentifier(rs.getString("call_identifier"))
     						.setStartdate(rs.getString("startdate"))
     						.setEnddate(rs.getString("enddate"))
     						.setOaMandateForPublications(rs.getBoolean("oa_mandate_for_publications"))
     						.setOaMandateForDatasets(rs.getBoolean("oa_mandate_for_datasets"))
     						.setDescription(rs.getString("description"))
     						.setOrgLegalname(rs.getString("legalname"))
     						.setOrgCountry(rs.getString("country"))
     						.setOrgRole(rs.getString("role"))
     						.setFirstname(rs.getString("firstname"))
     						.setSecondnames(rs.getString("secondnames"))
     						.setEmail(rs.getString("email"));
     		return outputStream;
+    	}
     				writeCSVLine(out, p.asList());
     	public void processTsvRequest(final OutputStream outputStream, final Boolean article293, final String fundingPrefix, final String filename) throws ApiException {
     		service.execute(() -> {
     			try(final ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(outputStream))) {
     				out.putNextEntry(new ZipEntry(filename));
     				writeTsvLine(out, Splitter.on(",").trimResults().splitToList(config.getProject().getTsvFields()));
     				queryForTsv(fundingPrefix, article293).forEach(p -> {
     					try {
     						writeTsvLine(out, p.asList());
     					} catch (IOException e) {
     						throw new RuntimeException(e);
+    					}
     				});
     			} catch (Throwable e) {
     				throw new RuntimeException("Error processing the request", e);
+    			}
     			out.closeEntry();
     			final LocalDateTime end = LocalDateTime.now();
     			if (log.isDebugEnabled()) {
     				log.debug("Thread " + Thread.currentThread().getId() + " ends, took: " + Duration.between(start, end));
+    			}
     		} finally {
     			out.close();
+    		}
     		});
+    	}
     	private void writeCSVLine(final ZipOutputStream out, final List<String> list) throws IOException {
     		out.write(Joiner.on('\t').useForNull("").join(list).getBytes(UTF8));
     	private void writeTsvLine(final ZipOutputStream out, final List<String> s) throws IOException {
     		out.write(Joiner.on('\t').useForNull("").join(s).getBytes(UTF8));
     		out.write('\n');
+    	}
     	private Iterable<ProjectTsv> queryForTsv(final String fundingPrefix, final Boolean article293) {
     		log.debug(String.format("fundingPrefix:'%s' and article293:'%s'", fundingPrefix, article293));
     		if (article293 != null) {
     			return projectTsvRepository.findByFundingpathidStartingWithAndOaMandateForDatasetsOrderByAcronym(fundingPrefix, article293);
     		} else {
     			return projectTsvRepository.findByFundingpathidStartingWithOrderByAcronym(fundingPrefix);
+    		}
+    	}
     	public void streamProjects(final String sql, final OutputStream out,
     			final String head, final StringTemplate projectTemplate, final String tail,
     			final ValueCleaner cleaner) throws IOException, SQLException {
     		service.execute(() -> {
     			try {
     				if (log.isDebugEnabled()) {
     					log.debug("Thread " + Thread.currentThread().getId() + " begin");
+    				}
     				final LocalDateTime start = LocalDateTime.now();
     				if (StringUtils.isNotBlank(head)) {
     					out.write(head.getBytes(UTF8));
+    				}
     				try (final Connection con = getConn(); final PreparedStatement stm = getStm(sql, con); final ResultSet rs = stm.executeQuery()) {
     					while (rs.next()) {
     						final Project p = new Project()
     								.setFunder(cleaner.clean(rs.getString("funder")))
     								.setJurisdiction(cleaner.clean(rs.getString("jurisdiction")))
     								.setFundingpathid(cleaner.clean(rs.getString("fundingpathid")))
     								.setAcronym(cleaner.clean(rs.getString("acronym")))
     								.setTitle(cleaner.clean(rs.getString("title")))
     								.setCode(cleaner.clean(rs.getString("code")))
     								.setStartdate(cleaner.clean(rs.getString("startdate")))
     								.setEnddate(cleaner.clean(rs.getString("enddate")));
     						projectTemplate.reset();
     						projectTemplate.setAttribute("p", p);
     						out.write(projectTemplate.toString().getBytes(UTF8));
+    					}
     					if (StringUtils.isNotBlank(tail)) {
     						out.write(tail.getBytes(UTF8));
+    					}
     					final LocalDateTime end = LocalDateTime.now();
     					if (log.isDebugEnabled()) {
     						log.debug("Thread " + Thread.currentThread().getId() + " ends, took: " + Duration.between(start, end));
+    					}
     				} finally {
     					out.close();
+    				}
     			} catch (IOException | SQLException e) {
     				log.error(e);
     				throw new RuntimeException(e);
+    			}
     		});
+    	}
     	private Connection getConn() throws SQLException {
     		final Connection conn = projectApiDataSource.getConnection();
     		conn.setAutoCommit(false);
-...
     	private PreparedStatement getStm(final String sql, final Connection con) throws SQLException {
     		final PreparedStatement stm = con.prepareStatement(sql);
     		stm.setFetchSize(maxRows);
     		stm.setFetchSize(config.getJdbc().getMaxRows());
     		return stm;
+    	}
     	private List<String> asList(final Array value) throws SQLException {
     		if (value != null) {
     			final List<Object> list = Arrays.asList((Object[]) value.getArray());
     			return Lists.newArrayList(Iterables.transform(list, new Function<Object, String>() {
     				@Override
     				public String apply(final Object o) {
     					return o != null ? o.toString() : null;
+    				}
     			}));
+    		}
     		return Lists.newArrayList();
+    	}
+    }

     			final String endUntil) {
     		ProjectQueryParams params = new ProjectQueryParams();
     		String[] arr = request.getPathInfo().replace(BASE_PATH, "").split("\\/");
     		String[] arr = request.getServletPath().replace(BASE_PATH, "").split("\\/");
     		if (arr.length != 5) throw new IllegalArgumentException("Invalid url");
     		params.setFundingProgramme(arr[0]);

     import java.io.BufferedOutputStream;
     import java.io.IOException;
     import java.io.OutputStream;
     import java.sql.SQLException;
     import java.text.SimpleDateFormat;
     import java.util.Arrays;
     import java.util.Date;
     import java.util.Map;
     import java.util.concurrent.atomic.AtomicInteger;
     import java.util.zip.GZIPOutputStream;
     import java.util.zip.ZipEntry;
     import java.util.zip.ZipOutputStream;
     import javax.servlet.ServletOutputStream;
     import javax.servlet.ServletResponse;
     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     import com.google.common.base.Joiner;
     import com.google.common.collect.Maps;
     import com.google.common.xml.XmlEscapers;
     import eu.dnetlib.OpenaireExporterConfig;
     import eu.dnetlib.OpenaireExporterConfig.Project;
     import eu.dnetlib.common.rmi.DNetRestDocumentation;
     import eu.dnetlib.openaire.exporter.datasource.ApiException;
     import eu.dnetlib.openaire.exporter.model.project.ProjectTsv;
     import eu.dnetlib.openaire.exporter.project.repository.ProjectDetailsRepository;
     import eu.dnetlib.openaire.exporter.project.repository.ProjectTsvRepository;
     import org.antlr.stringtemplate.StringTemplate;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.lang3.StringUtils;
-...
     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.core.io.Resource;
     import org.springframework.http.HttpStatus;
     import org.springframework.stereotype.Controller;
-...
     	public final static String UTF8 = "UTF-8";
     	@Value("${openaire.project.exporter.projectsfundings.sql.template}")
     	private Resource projectsFundingQueryTemplate;
     	@Autowired
     	private OpenaireExporterConfig config;
     	@Value("${openaire.project.exporter.projects2tsv.sql.template}")
     	private Resource projects2tsvQueryTemplate;
     	@Value("${openaire.project.exporter.dspace.template.project}")
     	private Resource dspaceTemplate;
     	@Value("${openaire.project.exporter.dspace.template.head}")
     	private Resource dspaceHeadTemplate;
     	@Value("${openaire.project.exporter.dspace.template.tail}")
     	private Resource dspaceTailTemplate;
     	@Value("${openaire.project.exporter.eprints.template}")
     	private Resource eprintsTemplate;
     	@Value("${openaire.project.exporter.projectdetails.sql}")
     	private Resource projectDetailsSql;
     	@Value("${openaire.project.exporter.projectdetails.flushsize}")
     	private int gzipFlushSize;
     	@Autowired
     	private JdbcApiDao dao;
     	@Autowired
     	private ProjectQueryParamsFactory projectQueryParamsFactory;
     	@Autowired
     	private ProjectDetailsRepository projectDetailsRepository;
     	@Autowired
     	private ProjectTsvRepository projectTsvRepository;
     	@Deprecated
     	/**
     	 * @deprecated  we should use the codes returned by the yet to come service
-...
+    	}
     	@RequestMapping(value = "/openaire/export/**/project/dspace.do", method = RequestMethod.GET)
     	void processDspace(final HttpServletRequest request,
     			final ServletResponse response,
     	void processDspace(final HttpServletRequest request, final ServletResponse response,
     			@RequestParam(value = "startFrom", required = false) final String startFrom,
     			@RequestParam(value = "startUntil", required = false) final String startUntil,
     			@RequestParam(value = "endFrom", required = false) final String endFrom,
     			@RequestParam(value = "endUntil", required = false) final String endUntil) throws Exception {
     		final Project conf = config.getProject();
     		final ProjectQueryParams params = projectQueryParamsFactory.generateParams(request, startFrom, startUntil, endFrom, endUntil);
     		final StringTemplate headSt = new StringTemplate(IOUtils.toString(dspaceHeadTemplate.getInputStream(), UTF8 ));
     		final StringTemplate headSt = new StringTemplate(IOUtils.toString(conf.getDspaceHeadTemplate().getInputStream(), UTF8));
     		headSt.setAttribute("fundingProgramme", params.getFundingProgramme());
     		final StringTemplate tailSt = new StringTemplate(IOUtils.toString(dspaceTailTemplate.getInputStream(), UTF8));
     		final StringTemplate tailSt = new StringTemplate(IOUtils.toString(conf.getDspaceTailTemplate().getInputStream(), UTF8));
     		response.setContentType("text/xml");
     		doProcess(response, params, headSt.toString(), dspaceTemplate, tailSt.toString(), s -> XmlEscapers.xmlContentEscaper().escape(oneLiner(s)));
     		doProcess(response, params, headSt.toString(), conf.getDspaceTemplate(), tailSt.toString(), s -> XmlEscapers.xmlContentEscaper().escape(oneLiner(s)));
+    	}
     	@RequestMapping(value = "/openaire/export/**/project/eprints.do", method = RequestMethod.GET)
     	void processEprints(final HttpServletRequest request,
     			final ServletResponse response,
     	void processEprints(final HttpServletRequest request, final ServletResponse response,
     			@RequestParam(value = "startFrom", required = false) final String startFrom,
     			@RequestParam(value = "startUntil", required = false) final String startUntil,
     			@RequestParam(value = "endFrom", required = false) final String endFrom,
     			@RequestParam(value = "endUntil", required = false) final String endUntil) throws Exception {
     		final Project conf = config.getProject();
     		final ProjectQueryParams params = projectQueryParamsFactory.generateParams(request, startFrom, startUntil, endFrom, endUntil);
     		response.setContentType("text/html");
     		doProcess(response, params, null, eprintsTemplate, null, s -> oneLiner(s));
     		doProcess(response, params, null, conf.getEprintsTemplate(), null, s -> oneLiner(s));
+    	}
     	private String oneLiner(final String s) {
-...
     			final ValueCleaner cleaner) throws IOException, SQLException {
     		final StringTemplate st = new StringTemplate(IOUtils.toString(projectTemplate.getInputStream(), UTF8));
     		dao.streamProjects(obtainQuery(params), response.getOutputStream(), head, st, tail, cleaner);
     		dao.streamProjects(obtainQuery(params), new BufferedOutputStream(response.getOutputStream()), head, st, tail, cleaner);
+    	}
     	@RequestMapping(value = "/openaire/export/project2tsv.do", method = RequestMethod.GET)
-...
     			@RequestParam(value = "funding", required = true) final String funding,
     			@RequestParam(value = "article293", required = false) final Boolean article293) throws Exception {
     		final String date = new SimpleDateFormat("yyyyMMdd").format(new Date());
     		final String filename = "projects_" + funding + "_" + date + ".tsv";
     		response.setContentType("text/tab-separated-values");
     		response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + ".zip\"");
     		final StringTemplate st = new StringTemplate(IOUtils.toString(projects2tsvQueryTemplate.getInputStream(), UTF8));
     		Funding requestedFunding = Funding.valueOf(funding.toUpperCase());
     		String fundingPrefix = getFundingPrefix(requestedFunding, null);
     		log.debug("Setting fundingprefix to " + fundingPrefix);
     		st.setAttribute("fundingprefix", fundingPrefix);
     		st.setAttribute("filters", expandFilters(article293));
     		final ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(response.getOutputStream()));
     		out.putNextEntry(new ZipEntry(filename));
     		dao.streamProjectsTSV(st.toString(), out);
+    	}
     	@RequestMapping(value = "/openaire/export/project2tsv2.do", method = RequestMethod.GET)
     	void processTsv2(final HttpServletRequest request, final HttpServletResponse response,
     			@RequestParam(value = "funding", required = true) final String funding,
     			@RequestParam(value = "article293", required = false) final Boolean article293) throws Exception {
     		final Funding requestedFunding = Funding.valueOf(funding.toUpperCase());
     		final String fundingPrefix = getFundingPrefix(requestedFunding, null);
-...
     		response.setContentType("text/tab-separated-values");
     		response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + ".zip\"");
     		try(final ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(response.getOutputStream()))) {
     			out.putNextEntry(new ZipEntry(filename));
     			queryForTsv(fundingPrefix, article293).forEach(p -> {
     				try {
     					out.write(Joiner.on('\t').useForNull("").join(p.asList()).getBytes(UTF8));
     					out.write('\n');
     				} catch (IOException e) {
     					throw new RuntimeException(e);
+    				}
     			});
     		} catch (Throwable e) {
     			throw new ApiException(org.apache.http.HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error processing the request", e);
+    		}
     		dao.processTsvRequest(response.getOutputStream(), article293, fundingPrefix, filename);
+    	}
     	private Iterable<ProjectTsv> queryForTsv(final String fundingPrefix, final Boolean article293) {
     		log.debug(String.format("fundingPrefix:'%s' and article293:'%s'", fundingPrefix, article293));
     		if (article293 != null) {
     			return projectTsvRepository.findByFundingpathidStartingWithAndOaMandateForDatasetsOrderByAcronym(fundingPrefix, article293);
     		} else {
     			return projectTsvRepository.findByFundingpathidStartingWithOrderByAcronym(fundingPrefix);
+    		}
+    	}
     	@RequestMapping(value = "/openaire/export/streamProjectDetails.do", method = RequestMethod.GET)
     	void streamProjectDetails(final HttpServletResponse response,
     			@RequestParam(value = "format", required = true) final String format,
-...
     			default: throw new IllegalArgumentException("unsupported format: " + format);
+    		}
     		final OutputStream out = getOutputStream(response.getOutputStream(), compress);
     		try {
     			final AtomicInteger i = new AtomicInteger(0);
     			projectDetailsRepository.findAll().forEach(p -> {
     					try {
     						switch (format) {
     						case "csv":
     							out.write(p.asCSV().getBytes(UTF8));
     							break;
     						case "json":
     							out.write(p.asJson().getBytes(UTF8));
     							break;
+    						}
     						i.incrementAndGet();
     						if (i.intValue() % gzipFlushSize == 0) {
     							log.debug("flushing output stream");
     							out.flush();
+    						}
     					} catch (IOException e) {
     						throw new RuntimeException(e);
+    					}
+    				}
     			);
     		} finally {
     			if (out instanceof GZIPOutputStream) {
     				((GZIPOutputStream) out).finish();
+    			}
     			out.close();
+    		}
     		dao.processProjectDetails(response.getOutputStream(), format, compress);
+    	}
     	private OutputStream getOutputStream(final ServletOutputStream outputStream, final Boolean compress) throws IOException {
     		if (compress != null && compress) {
     			return new GZIPOutputStream(outputStream);
+    		}
     		return outputStream;
+    	}
     	@ExceptionHandler({Exception.class, Throwable.class})
     	@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
     	public @ResponseBody ErrorMessage handleSqlException(final Exception e) {
-...
+    		}
+    	}
     	private Map<String, String> expandFilters(final Boolean article293) {
     		final Map<String, String> res = Maps.newHashMap();
     		if (article293 != null) {
     			res.put("ec_article29_3", String.valueOf(article293));
+    		}
     		return res;
+    	}
     	/**
     	 * Creates the query on the fundingProgramme specified in the given parameters.
+    	 *
-...
     		String funding = params.getFundingProgramme();
     		String suffix = params.getFundingPath();
     		String fundingPrefix = getFundingPrefix(Funding.valueOf(funding.toUpperCase()), suffix);
     		final StringTemplate st = new StringTemplate(IOUtils.toString(projectsFundingQueryTemplate.getInputStream(), UTF8));
     		final StringTemplate st = new StringTemplate(IOUtils.toString(config.getProject().getProjectsFundingQueryTemplate().getInputStream(), UTF8));
     		st.setAttribute("fundingprefix", fundingPrefix);
     		String theQuery = setDateParameters(st.toString(), params);
     		log.debug("Generated query: " + theQuery);
-...
     		return queryWithDates;
+    	}
     	public void setProjectsFundingQueryTemplate(final Resource projectsFundingQueryTemplate) {
     		this.projectsFundingQueryTemplate = projectsFundingQueryTemplate;
+    	}
+    }

     package eu.dnetlib.openaire.exporter.datasource.clients;
     import java.nio.charset.Charset;
     import eu.dnetlib.OpenaireExporterConfig;
     import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
     import eu.dnetlib.openaire.exporter.datasource.ApiException;
     import eu.dnetlib.openaire.exporter.datasource.clients.utils.IndexDsInfo;
-...
     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.cache.annotation.Cacheable;
     import org.springframework.core.io.ClassPathResource;
     import org.springframework.http.HttpStatus;
     import org.springframework.stereotype.Component;
-...
     	private static final Log log = LogFactory.getLog(ISLookupClient.class);
     	@Autowired
     	private OpenaireExporterConfig config;
     	@Autowired
     	private ISLookUpService isLookUpService;
     	@Value(value = "${openaire.datasource.publisher.findSolrIndexUrl.xquery}")
     	private ClassPathResource findSolrIndexUrl;
     	@Value(value = "${openaire.datasource.publisher.findIndexDsInfo.xquery}")
     	private ClassPathResource findIndexDsInfo;
     	@Cacheable("datasources-is-cache")
     	public IndexDsInfo calculateCurrentIndexDsInfo() throws ApiException {
     		log.warn("calculateCurrentIndexDsInfo(): not using cache");
     		try {
     			final String queryUrl = IOUtils.toString(findSolrIndexUrl.getInputStream());
     			final String queryDs = IOUtils.toString(findIndexDsInfo.getInputStream());
     			final String queryUrl = IOUtils.toString(config.getFindSolrIndexUrl().getInputStream(), Charset.defaultCharset());
     			final String queryDs = IOUtils.toString(config.getFindIndexDsInfo().getInputStream(), Charset.defaultCharset());
     			final String indexBaseUrl = isLookUpService.getResourceProfileByQuery(queryUrl);
     			final String[] arr = isLookUpService.getResourceProfileByQuery(queryDs).split("@@@");

     import java.util.Queue;
     import java.util.concurrent.*;
     import javax.annotation.PostConstruct;
     import com.google.common.collect.Lists;
     import com.google.common.util.concurrent.*;
     import eu.dnetlib.OpenaireExporterConfig;
     import eu.dnetlib.openaire.exporter.datasource.ApiException;
     import eu.dnetlib.openaire.exporter.datasource.clients.utils.IndexDsInfo;
     import eu.dnetlib.openaire.exporter.datasource.clients.utils.IndexRecordsInfo;
-...
     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.stereotype.Component;
-...
     	private static final Log log = LogFactory.getLog(DatasourceDao.class);
     	@Autowired
     	private OpenaireExporterConfig config;
     	@Autowired
     	private MongoLoggerClient mongoLoggerClient;
     	@Autowired
-...
     	private ListeningExecutorService service;
     	private final static int WORKERS = 100;
     	@Value("${openaire.datasource.publisher.timeout}")
     	private int timeout = 10;
     	public DatasourceDao() {
     	@PostConstruct
     	public void init() {
     		service = MoreExecutors.listeningDecorator(
     				new ScheduledThreadPoolExecutor(WORKERS,
     				new ScheduledThreadPoolExecutor(config.getRequestWorkers(),
     						new ThreadFactoryBuilder().setNameFormat("datasource-info-retriever-%d").build()));
+    	}
-...
     				dsRepository.findByOfficialnameContainingOrEnglishnameContainingAllIgnoreCase(name, name, pageable);
     		c.addCallback(getSearchCallback(outerLatch, errors, datasourceResponse));

Project

General

Profile

D-Net

Revision 48399

Added by Claudio Atzori about 7 years ago