D-Net

{

  "type_source": "SVN", 

  "goal": "package -U -T 4C source:jar", 

  "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-openaire-connector/trunk", 

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

  "mail": "antleb@di.uoa.gr, kiatrop@di.uoa.gr", 

  "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet4-snapshots", 

  "name": "uoa-openaire-connector"

}

package eu.dnetlib.openaire.thrift;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.protocol.TProtocol;

import org.apache.thrift.transport.TSocket;

import org.apache.thrift.transport.TTransport;

import org.apache.thrift.transport.TTransportException;

import eu.dnetlib.openaire.thrift.OpenAIREConnector;

public class ThriftClient {

	public OpenAIREConnector.Client getConnector() throws TTransportException {

		return getConnector("localhost", 7911);

	}

	public OpenAIREConnector.Client getConnector(String host, int port) throws TTransportException {

		TTransport transport = new TSocket(host, port);

		transport.open();

		TProtocol protocol = new  TBinaryProtocol(transport);

		return new OpenAIREConnector.Client(protocol);

	}

}

package eu.dnetlib.openaire.thrift;

import org.apache.thrift.TException;

import java.util.Arrays;

/**

 * Created by antleb on 6/20/14.

 */

public class TestConnector {

	public static void main(String[] args) throws TException {

		OpenAIREConnector.Client client = new ThriftClient().getConnector("194.177.192.223", 7911);

		String id = client.insertDocument("123123/3434.23", "doi", "a title", " a description", "OPEN ACCESS", null, Arrays.asList(new Author("id" ,"lastname", "firstname")), "url", "dcsource", "antleb@di.uoa.gr", Arrays.asList("subject"), "2012-01-02", "publisher", "language", "category", "doioioioi" );

		System.out.println(id);

		client.insertConcept(id, "doi", "egi", "antleb@di.uoa.gr", "123");

		client.insertProjectRelation(id, "doi", new Project("ec", "1233312"), "antleb@di.uoa.gr");

		client.insertProjectRelation(id, "doi", new Project(null, "1233312"), "antleb@di.uoa.gr");

		client.insertResultRelation(id, "result", "doi", id, "result", "antleb@di.uoa.gr");

		id = "od______1406::fbda7b28cda277b04c8dc27a5e0deb68";

		client.insertConcept(id, "openaire", "ec", "antleb@di.uoa.gr", "123");

		client.insertProjectRelation(id, "openaire", new Project("ec", "099809987"), "antleb@di.uoa.gr");

		client.insertProjectRelation(id, "openaire", new Project(null, "098908908"), "antleb@di.uoa.gr");

		client.insertResultRelation(id, "result", "openaire", id, "dataset", "antleb@di.uoa.gr");

	}

}

<RELATIONS>

#foreach ($rel in $relations)

    <RELATION type='$rel.Type' source='$rel.SourceId' target='$rel.TargetId' />

#end

</RELATIONS>

openaire.connector.thrift.port = 7911

openaire.connector.thrift.timeout = 15000

openaire.connector.unknownRepositoryName = Unknown Repository

openaire.db.driverClassName = org.postgresql.Driver

openaire.db.url = jdbc:postgresql://194.177.192.223:5432/dnet_claims

openaire.db.username = dnet

openaire.db.password = dnetPwd

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:tx="http://www.springframework.org/schema/tx"

        xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd">

	<bean id="openaire.dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

		<property name="driverClassName" value="${openaire.db.driverClassName}" />

		<property name="url" value="${openaire.db.url}" />

		<property name="username" value="${openaire.db.username}" />

		<property name="password" value="${openaire.db.password}" />

		<property name="maxIdle" value="10" />

		<property name="maxActive" value="100" />

		<property name="maxWait" value="10000" />

		<property name="validationQuery" value="SELECT 1;" />

		<property name="testOnBorrow" value="true" />

		<property name="testOnReturn" value="true" />

		<property name="testWhileIdle" value="true" />

		<property name="timeBetweenEvictionRunsMillis" value="1200000" />

		<property name="minEvictableIdleTimeMillis" value="1800000" />

		<property name="numTestsPerEvictionRun" value="5" />

		<property name="poolPreparedStatements" value="true" />

		<property name="defaultAutoCommit" value="true" />

	</bean>

	<bean id="claimConnector" class="eu.dnetlib.openaire.thrift.ClaimConnector">

		<property name="datasource" ref="openaire.dataSource" />

		<property name="lookupServiceLocator" ref="lookupServiceLocator"/>

	</bean>

	<bean id="alertConnector" class="eu.dnetlib.openaire.thrift.AlertConnector">

		<property name="alertServiceLocator" ref="alertServiceLocator" />

	</bean>

	<bean id="openAireConnector" class="eu.dnetlib.openaire.thrift.OpenAIREConnectorImpl">

		<property name="claimConnector" ref="claimConnector" />

		<property name="alertConnector" ref="alertConnector" />

	</bean>

	<bean id="thriftServer" class="eu.dnetlib.openaire.thrift.ThriftServer" init-method="start" destroy-method="stop">

		<property name="openAireConnector" ref="openAireConnector" />

		<property name="port" value="${openaire.connector.thrift.port}"/>

		<property name="timeout" value="${openaire.connector.thrift.timeout}" />

	</bean>

    <tx:annotation-driven transaction-manager="txManager"/>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="openaire.dataSource"/>

    </bean>

</beans>

select

        r.resultid                                          as dri_objidentifier,

        r.title                                             as dc_title,

        array_agg(DISTINCT lpad('0'||aut.rank,5,'0')||'§§§'||ltrim(replace(per.surname||', '||per.name,'UNKNOWN, ',''), ', ')) as dc_creator,

      r.description                                       as dc_description,

        r.publisher                                         as dc_publisher,

        r.keywords                                          as dc_subject,

        r.language                                          as dc_language,

        array_agg(DISTINCT ws.file_url)                     as dc_identifier,

        r.publication_date                                  as oaf_publicationdate,

        r.embargo_end_date                                  as oaf_embargoenddate,

        r.access_mode                                       as oaf_accessmode,

        r.haskind                                           as oaf_haskind,

        r.hastype                                           as "dr_CobjCategory",

        r.storagedate                                           as oaf_storagedate,

        createdfrom                                         as createdfrom,

        array_agg(DISTINCT p.projectid)                     as oaf_projectid,

        array_agg(DISTINCT cr.creator)                              as creators

from

       results r

        left outer join results_projects rp on (r.resultid = rp.result)

        left outer join projects p on (p.projectid = rp.project)

        left outer join projects_projectsubjects ps on (ps.project = p.projectID)

        left outer join fundingschemes fs on (p.fundedhow = fs.fundingschemeid)

        left outer join programs s on (p.fundedby = s.programid)

        left outer join specificprograms sp on (s.hasspecificprogram = sp.specificprogramid)

        left outer join frameworkprograms fp on (sp.hasframeworkprogram = fp.frameworkprogramid)

        left outer join authorships aut on (r.resultid = aut.result)

        left outer join persons per on (per.personid = aut.author)

        left outer join organizations o on (o.organizationid = aut.affiliation)

        left outer join instances i on (r.resultid = i.resource)

        left outer join webresources_instances wsi on (wsi.instanceid = i.instanceid)

        left outer join webresources ws on (ws.webresourceid = wsi.webresourceid)

        join creations cr on cr.creation = r.resultid

where

        r.pmhdeleted != true and r.pendingforclaim = false

group by

        r.resultid, r.title, r.description, r.publisher, r.keywords, r.language,

        r.publication_date, r.embargo_end_date, r.access_mode, r.haskind, r.hastype,

        r.storagedate, r.createdfrom

<?xml version="1.0" encoding="UTF-8"?>

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="false">

    <!--

     | Please see http://ehcache.sourceforge.net/documentation/configuration.html for

     | detailed information on how to configurigure caches in this file

     +-->

    <!-- Location of persistent caches on disk -->

    <diskStore path="java.io.tmpdir/EhCacheSpringAnnotationsExampleApp" />

    <defaultCache eternal="true" maxElementsInMemory="10000"

        overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"

        timeToLiveSeconds="0" memoryStoreEvictionPolicy="LRU"/>

	<cache name="claimator"/>

	<cache name="alertator.subscriptions"/>

	<cache name="querynator"/>

</ehcache>

namespace java eu.dnetlib.openaire.thrift

struct Author {

	1: string id,

	2: string lastName,

	3: string firstName

}

// alerts

struct AlertSubscription {

	1: string templateId,

	2: string notificationService,

	3: string queryId,

	4: string resultId,

	5: string alertMode,

	6: string subscriber

}

struct ResultPage {

	1: i32 limit,

	2: i32 offset,

	3: list<string> columns,

	4: list<list<string>> rows

}

struct Claim {

    1: string userEmail,

	2: string resultid,

	3: i64 date,

	4: string type,

	5: string xml,

	6: string id

}

struct Project {

    1: string type,

    2: string projectId

}

// connector

service OpenAIREConnector {

	// claim

	list<Claim> getClaimedPublications(1: string userEmail),

	// from: date in milisecs

	// to: ditto

	list<Claim> getAllClaimedPublications(1: i64 from, 2: i64 to),

	string insertDocument (

			1: string originalId,

			2: string source, 

			3: string title, 

			4: string description, 

			5: string access_mode, 

			6: string embargoEndDate, 

			7: list<Author> authors, 

			8: string url,

			9: string dcSource,

			10: string userEmail,

			11: list<string> subjects,

			12: string publicationDate,

			13: string publisher,

			14: string language,

			15: string category,

			16: string doi),

    void insertConcept (

        1: string docId,

        2: string documentSource,

        3: string concept,

        4: string userEmail,

        5: string doi),

    void insertProjectRelation (

        1: string docId,

        2: string documentSource,

        3: Project project,

        4: string userEmail),

    void insertResultRelation (

        1: string sourceResultId,

        2: string sourceResultType,

        3: string sourceResultSource,

        4: string targetResultId,

        5: string targetResultType,

        6: string userEmail

    ),

	void deleteClaim(1: string userEmail, 2:string resultId),

	// alerts

	list<AlertSubscription> getSubscriptions(

			1: string alertMode, 

			2: string subscriber, 

			3: i32 limit, 

			4: i32 offset),

	void addSubscription(1: AlertSubscription subscription),

	void removeSubscription(1: AlertSubscription subscription),

	i32 countAlertResults(

			1: string notificationService, 

			2: string queryId, 

			3: i64 date, 

			5: string resultId),

	ResultPage getAlertResults(

			1: string notificationService, 

			2: string queryId, 

			3: string resultId, 

			4: i64 fromDate, 

			5: i64 toDate, 

			6: i32 limit, 

			7: i32 offset),

	list<string> getContexts(),

}

package eu.dnetlib.openaire.action;

public class Relation {

	private String type;

	private String sourceId;

	private String targetId;

	public Relation(String type, String sourceId, String targetId) {

		super();

		this.type = type;

		this.sourceId = sourceId;

		this.targetId = targetId;

	}

	public String getType() {

		return type;

	}

	public void setType(String type) {

		this.type = type;

	}

	public String getSourceId() {

		return sourceId;

	}

	public void setSourceId(String sourceId) {

		this.sourceId = sourceId;

	}

	public String getTargetId() {

		return targetId;

	}

	public void setTargetId(String targetId) {

		this.targetId = targetId;

	}

}

package eu.dnetlib.openaire.action;

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.openaire.thrift.Author;

import eu.dnetlib.openaire.thrift.Project;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.lang.StringEscapeUtils;

import org.apache.log4j.Logger;

import org.apache.velocity.Template;

import org.apache.velocity.VelocityContext;

import org.apache.velocity.app.VelocityEngine;

import org.apache.velocity.runtime.RuntimeConstants;

import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;

import java.io.StringWriter;

import java.security.MessageDigest;

import java.util.ArrayList;

import java.util.List;

import java.util.regex.Pattern;

public class ActionUtils {

	private static Logger logger = Logger.getLogger(ActionUtils.class);

	public static String createResultProjectRelation(String source,

			String resultId, String projectType, String projectId)

			throws Exception {

		VelocityEngine ve = new VelocityEngine();

		ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");

		ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());

		ve.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem");

		ve.init();

		Template t = ve.getTemplate("/eu/dnetlib/openaire/action/relation.vm");

		VelocityContext vc = new VelocityContext();

		List<Relation> rels = new ArrayList<Relation>();

		rels.add(createRelation(source, resultId, projectType, projectId));

		vc.put("relations", rels);

		StringWriter sw = new StringWriter();

		t.merge(vc, sw);

		return sw.toString();

	}

    public static String createResultResultRelation(String sourceResultId, String sourceResultType, String targetResultId, String targetResultType) {

        VelocityEngine ve = new VelocityEngine();

        ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");

        ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());

        ve.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem");

        ve.init();

        Template t = ve.getTemplate("/eu/dnetlib/openaire/action/relation.vm");

        VelocityContext vc = new VelocityContext();

        List<Relation> rels = new ArrayList<Relation>();

        rels.add(new Relation("resultResult_" + sourceResultType + targetResultType + "_isRelatedTo", "50|" + sourceResultId, "50|" + targetResultId));

        vc.put("relations", rels);

        StringWriter sw = new StringWriter();

        t.merge(vc, sw);

        return sw.toString();

    }

	// input id: 1306.3402

	// oai:arXiv.org:1306.3402

	// MD5("od________18::oai:arXiv.org:1306.3402")

    /**

     * Creates a new relation action.

     * @param source the result source. If not null, the resultId is transformed to openaire id. If null, the result is

     *               considered to be already an openaire result and is used verbatim

     * @param resultId the result id

     * @param projectType the project type. If not null, the projectId is transformed to openaire id. If null, the projectId is

     *               considered to be already in openaire format and is used verbatim

     * @param projectId the project id

     *

     * @return a relation

     */

	private static Relation createRelation(String source, String resultId,

			String projectType, String projectId) {

		String resultPrefix;

		String projectPrefix = null;

        if (!isValidOpenaireId(resultId) && source != null) {

            if (source.equals("arxiv")) {

                resultId = "oai:arXiv.org:" + resultId;

            } else if (source.equals("pubmed")) {

                resultId = "oai:europepmc.org:" + resultId;

            }

            resultPrefix = getPrefix(source);

            resultId = getIdentifier(resultPrefix, resultId);

        }

	resultId = "50|" + resultId;

        if (projectType != null) {

            if (projectType.equals("ec")) {

                projectPrefix = "corda_______";

            } else if (projectType.equals("wt")) {

                projectPrefix = "wt__________::WT";

            }

            projectId = projectPrefix + "::" + projectId;

        }

	projectId = "40|" + projectId;

		return new Relation("resultProject", resultId, projectId);

	}

	private static boolean isValidOpenaireId(String resultId) {

		return Pattern.matches("\\w{12}::[a-f0-9]{32}", resultId);

	}

	public static String getPrefix(String source) {

        logger.debug("SOURCE " + source);

		if (source == null || source.equals("openaire")) {

			return "openaire____";

		} else if (source.equals("doi")) {

			return "crossref____";

		} if (source.equals("orcid")) {

            		return "orcid_______";

		} else if (source.equals("datacite")) {

			return "datacite____";

		} else if (source.equals("driver")) {

			return "driver______";

		} else

			return null;

	}

    public static String getProvenance(String source) {

        if (source == null || source.equals("openaire"))

            return "user:claim:search";

        else if (source.equals("doi") || source.equals("orcid"))

            return "user:claim:pid";

		else if (source.equals("datacite"))

			return "user:claim:datacite";

        else

            return null;

    }

	public static String createDMF(String id, String source, String title,

			String description, String access_mode, String embargoEndDate,

			List<Author> authors, String url, String dcSource, String doi,

			List<Project> projects, List<String> subjects, List<String> concepts, String publicationDate, String publisher, String language, String category, boolean isConcept) throws Exception {

        logger.info("create with doi " + doi);

		VelocityEngine ve = new VelocityEngine();

		ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");

		ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());

		ve.setProperty("runtime.log.logsystem.class", "org.apache.velocity.runtime.log.NullLogSystem");

		ve.init();

		Template t = ve.getTemplate("/eu/dnetlib/openaire/action/dmf.vm");

		VelocityContext vc = new VelocityContext();

		String hostedby = null;

		String hostedbyName = null;

		String collectedFrom = null;

		String collectedFromName = null;

        String recordIdentifier = id;

		String prefix = getPrefix(source);

        //if the orcid id exists

        String orcid = null;

		if (source.equals("doi") && !isConcept) {

			hostedby = "openaire____::1256f046-bf1f-4afc-8b47-d0b147148b18";

			hostedbyName = "Unknown Repository";

			collectedFrom = "openaire____::crossref";

			collectedFromName = "Crossref";

			doi = id;

        } else if (source.equals("datacite")) {

            hostedby = "openaire____::1256f046-bf1f-4afc-8b47-d0b147148b18";

            hostedbyName = "Unknown Repository";

            collectedFrom = "openaire____::datacite";

            collectedFromName = "Datacite";

        } else if (source.equals("orcid")) {

            orcid = id;

            hostedby = "openaire____::1256f046-bf1f-4afc-8b47-d0b147148b18";

            hostedbyName = "Unknown Repository";

            collectedFrom = "openaire____::orcid";

            collectedFromName = "ORCID";

        } else if (source.equals("driver")) {

            hostedby = "openaire____::1256f046-bf1f-4afc-8b47-d0b147148b18";

            hostedbyName = "Unknown Repository";

            collectedFrom = "openaire____::driver";

            collectedFromName = "Digital Repository Infrastructure Vision for European Research";

        }

        logger.info("create with doi " + doi);

        if (doi != null) {

            vc.put("doi", doi);

        } else if (orcid != null){

          //if there is no doi but we have an orcid, id we store it

          vc.put("orcid", orcid);

        }

        // openaire ids should not be touched!

        if (!source.equals("openaire"))

		    id = getIdentifier(prefix, id);

		vc.put("objIdentifier", id);

		vc.put("recordIdentifier", recordIdentifier);

		vc.put("dateOfCollection", DateUtils.calculate_ISO8601(System.currentTimeMillis()));

		vc.put("hostedby", hostedby);

		vc.put("collectedFrom", collectedFrom);

		vc.put("hostedbyName", hostedbyName);

		vc.put("collectedFromName", collectedFromName);

        vc.put("embargoEndDate", embargoEndDate);

		vc.put("title", title);

		vc.put("description", description);

		vc.put("accessMode", access_mode);

		vc.put("dcSource", dcSource);

		vc.put("url", url);

		vc.put("publisher", publisher);

		vc.put("language", language);

		vc.put("objCategory", category);

		vc.put("datasourceprefix", prefix);

		List<String> creators = new ArrayList<String>();

		for (Author author : authors) {

            String name = author.getLastName();

            if (author.getFirstName() != null && !author.getFirstName().trim().isEmpty())

                name += ", " + author.getFirstName();

            creators.add(name);

		}

		vc.put("creators", creators);

		vc.put("projects", projects);

		vc.put("subjects", subjects);

        vc.put("concepts", concepts);

		if (publicationDate != null && !publicationDate.equals(""))

			vc.put("publicationDate", publicationDate + "-01-01T00:00:00Z");

		vc.put("StringEscapeUtils", StringEscapeUtils.class);

		StringWriter sw = new StringWriter();

		t.merge(vc, sw);

		return sw.toString();

	}

	// private static String getIdentifier(String prefix, String id) {

	// return prefix + "::" +

	// com.google.common.hash.Hashing.md5().hashString(id).toString();

	// }

	public static String getIdentifier(String prefix, String id) {

		try {

            logger.debug("PREFIX " + prefix);

			MessageDigest md = MessageDigest.getInstance("MD5");

			md.update(id.getBytes("UTF-8"));

			return prefix + "::" + new String(Hex.encodeHex(md.digest()));

		} catch (Exception e) {

			logger.error("Error creating id", e);

			return null;

		}

	}

}

package eu.dnetlib.openaire.thrift;

import org.apache.log4j.Logger;

import org.apache.thrift.server.TThreadPoolServer;

import org.apache.thrift.transport.TServerSocket;

import org.apache.thrift.transport.TTransportException;

public class ThriftServer {

	private OpenAIREConnector.Iface openAireConnector;

	private int port;

	private int timeout;

	private Thread thread;

	public void setOpenAireConnector(final OpenAIREConnector.Iface openAireConnector) {

		this.openAireConnector = openAireConnector;

	}

	public void setPort(final int port) {

		this.port = port;

	}

	public void setTimeout(final int timeout) {

		this.timeout = timeout;

	}

	public void start() {

		thread = new Thread(new Runnable() {

			@Override

			public void run() {

				try {

					new TThreadPoolServer(new TThreadPoolServer.Args(new TServerSocket(port, timeout)).processor(new OpenAIREConnector.Processor<OpenAIREConnector.Iface>(openAireConnector))).serve();

				} catch (final TTransportException e) {

					Logger.getLogger(ThriftServer.class).error("Error starting thrift server", e);

				}

			}

		});

		thread.start();

	}

	public void stop() {

		thread.interrupt();

	}

}

package eu.dnetlib.openaire.thrift;

import eu.dnetlib.api.functionality.AlertServiceException;

import org.apache.log4j.Logger;

import org.apache.thrift.TException;

import java.net.MalformedURLException;

import java.net.URISyntaxException;

import java.util.Date;

import java.util.List;

public class OpenAIREConnectorImpl implements OpenAIREConnector.Iface {

	private static final Logger logger = Logger.getLogger(OpenAIREConnectorImpl.class);

	private ClaimConnector claimConnector;

	private AlertConnector alertConnector;

	public void setClaimConnector(final ClaimConnector claimConnector) {

		this.claimConnector = claimConnector;

	}

	public void setAlertConnector(final AlertConnector alertConnector) {

		this.alertConnector = alertConnector;

	}

	@Override

	public List<Claim> getClaimedPublications(final String user) throws TException {

		try {

			return claimConnector.getClaimedPublications(user);

		} catch (final Exception e) {

			logger.error("Error retrieving claimed publications (user: " + user + ")", e);

			throw new TException("Error retrieving claimed publications (user: " + user + ")", e);

		}

	}

    @Override

    public List<Claim> getAllClaimedPublications(long from, long to) throws TException {

        try {

            return claimConnector.getClaimedPublications(new Date(from), new Date(to));

        } catch (Exception e) {

            logger.error("Error retrieving claimed publications", e);

            throw new TException("Error retrieving claimed publications", e);

        }

    }

    @Override

    public String insertDocument(String originalId, String source, String title, String description, String access_mode, String embargoEndDate, List<Author> authors, String url, String dcSource, String userEmail, List<String> subjects, String publicationDate, String publisher, String language, String category, String doi) throws org.apache.thrift.TException {

        try {

            return claimConnector.insertDocument(originalId, source, title, description, access_mode, embargoEndDate, authors, url, dcSource, userEmail, subjects, publicationDate, publisher, language, category, doi);

        } catch (Exception e) {

            logger.error("Error adding document", e);

            throw new TException(e);

        }

    }

    @Override

    public void insertConcept(String docId, String documentSource, String concept, String userEmail, String doi) throws org.apache.thrift.TException {

        try {

            claimConnector.insertConceptRelation(docId, documentSource, concept, userEmail, doi);

        } catch (Exception e) {

            logger.error("Error adding concept relation", e);

            throw new TException(e);

        }

    }

    @Override

    public void insertProjectRelation(String docId, String documentSource, Project project, String userEmail) throws org.apache.thrift.TException {

        try {

            claimConnector.insertProjectRelation(docId, documentSource, project, userEmail);

        } catch (Exception e) {

            logger.error("Error adding project relation", e);

            throw new TException(e);

        }

    }

    @Override

    public void insertResultRelation(String sourceResultId, String sourceResultType, String sourceResultSource, String targetResultId, String targetResultType, String userEmail) throws TException {

        try {

            claimConnector.insertResultRelation(sourceResultId, sourceResultType, sourceResultSource, targetResultId, targetResultType,userEmail);

        } catch (Exception e) {

            logger.error("Error adding result relation", e);

            throw new TException(e);

        }

    }

    @Override

	public List<AlertSubscription> getSubscriptions(final String alertMode, final String subscriber, final int limit, final int offset) throws TException {

		try {

			return alertConnector.getSubscriptions(alertMode, subscriber, limit, offset);

		} catch (final AlertServiceException e) {

			logger.error("Error retrieving subscriptions (alert mode: " + alertMode + ", subscriber: " + subscriber + ", limit: " + limit + ", offset: " + offset + ")", e);

			throw new TException("Error retrieving subscriptions (alert mode: " + alertMode + ", subscriber: " + subscriber + ", limit: " + limit + ", offset: " + offset + ")", e);

		}

	}

	@Override

	public void addSubscription(final AlertSubscription subscription) throws TException {

		try {

			alertConnector.addSubscription(subscription);

		} catch (final AlertServiceException e) {

			logger.error("Error adding subscription", e);

			throw new TException("Error adding subscription", e);

		} catch (final MalformedURLException e) {

			logger.error("Error adding subscription", e);

			throw new TException("Error adding subscription", e);

		} catch (final URISyntaxException e) {

			logger.error("Error adding subscription", e);

			throw new TException("Error adding subscription", e);

		}

	}

	@Override

	public void removeSubscription(final AlertSubscription subscription) throws TException {

		try {

			alertConnector.removeSubscription(subscription);

		} catch (final AlertServiceException e) {

			logger.error("Error removing subscription", e);

			throw new TException("Error removing subscription", e);

		} catch (final MalformedURLException e) {

			logger.error("Error removing subscription", e);

			throw new TException("Error removing subscription", e);

		} catch (final URISyntaxException e) {

			logger.error("Error removing subscription", e);

			throw new TException("Error removing subscription", e);

		}

	}

	@Override

	public int countAlertResults(final String notificationService, final String queryId, final long date, final String resultId) throws TException {

		try {

			return alertConnector.countAlertResults(notificationService, queryId, date, resultId);

		} catch (final AlertServiceException e) {

			logger.error("Error counting alert results (notification service: " + notificationService + ", query: " + queryId + ", date: " + date + ", result: " + resultId + ")", e);

			throw new TException("Error counting alert results (notification service: " + notificationService + ", query: " + queryId + ", date: " + date + ", result: " + resultId + ")", e);

		} catch (final MalformedURLException e) {

			logger.error("Error counting alert results (notification service: " + notificationService + ", query: " + queryId + ", date: " + date + ", result: " + resultId + ")", e);

			throw new TException("Error counting alert results (notification service: " + notificationService + ", query: " + queryId + ", date: " + date + ", result: " + resultId + ")", e);

		}

	}

	@Override

	public ResultPage getAlertResults(final String notificationService, final String queryId, final String resultId, final long fromDate, final long toDate, final int limit, final int offset) throws TException {

		try {

			return alertConnector.getAlertResults(notificationService, queryId, resultId, fromDate, toDate, limit, offset);

		} catch (final AlertServiceException e) {

			logger.error("Error retrieving alert results (notification service: " + notificationService + ", query: " + queryId + ", result: " + resultId + ", from date: " + fromDate + ", to date: " + toDate + ", limit: " +

					limit + ", offset: " + offset + ")", e);

			throw new TException("Error retrieving alert results (notification service: " + notificationService + ", query: " + queryId + ", result: " + resultId + ", from date: " + fromDate + ", to date: " + toDate +

					", limit: " + limit + ", offset: " + offset + ")", e);

		} catch (final MalformedURLException e) {

			logger.error("Error retrieving alert results (notification service: " + notificationService + ", query: " + queryId + ", result: " + resultId + ", from date: " + fromDate + ", to date: " + toDate + ", limit: " +

					limit + ", offset: " + offset + ")", e);

			throw new TException("Error retrieving alert results (notification service: " + notificationService + ", query: " + queryId + ", result: " + resultId + ", from date: " + fromDate + ", to date: " + toDate +

					", limit: " + limit + ", offset: " + offset + ")", e);

		}

	}

    @Override

    public void deleteClaim(String userEmail, String resultId) throws TException {

        try {

            claimConnector.deleteClaim(userEmail, resultId);

        } catch (Exception e) {

            logger.error("Error deleting claim", e);

            throw new TException(e);

        }

    }

	@Override

	public List<String> getContexts() throws TException {

		try {

			return claimConnector.getContexts();

		} catch (Exception e) {

			logger.error("Error getting contexts from IS.", e);

			throw new TException(e);

		}

	}

}

package eu.dnetlib.openaire.thrift;

import eu.dnetlib.api.enabling.ISLookUpService;

import eu.dnetlib.api.enabling.ISLookUpServiceException;

import eu.dnetlib.openaire.action.ActionUtils;

import gr.uoa.di.driver.enabling.ISLookUpException;

import gr.uoa.di.driver.util.ServiceLocator;

import org.apache.log4j.Logger;

import org.apache.velocity.exception.ParseErrorException;

import org.apache.velocity.exception.ResourceNotFoundException;

import org.springframework.jdbc.datasource.DataSourceUtils;

import org.springframework.transaction.annotation.Transactional;

import javax.sql.DataSource;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Date;

import java.util.List;

@Transactional

public class ClaimConnector {

	private static Logger logger = Logger.getLogger(ClaimConnector.class);

	private DataSource datasource = null;

	//Using an isLookUp Impl just to make an xQuery to IS. Maybe move all the

	//functionality to commons?

	private ServiceLocator<ISLookUpService> lookupServiceLocator = null;

	public List<Claim> getClaimedPublications(final String user) throws SQLException {

		Connection con = DataSourceUtils.getConnection(datasource);

		PreparedStatement stmt = con.prepareStatement("select \"resultid\", \"date\" , \"type\", \"xml\", \"id\" from claims where \"agent\" = ?");

		stmt.setString(1, user);

		ResultSet rs = stmt.executeQuery();

		List<Claim> res = new ArrayList<Claim>();

		while (rs.next()) {

			res.add(new Claim(user, rs.getString(1), rs.getTimestamp(2).getTime(), rs.getString(3), rs.getString(4), rs.getString(5)));

		}

		rs.close();

		stmt.close();

        logger.info("Returning " + res.size() + " claimed publications for user "  + user);

		return res;

	}

	public List<Claim> getClaimedPublications(Date from, Date to) throws SQLException {

		Connection con = DataSourceUtils.getConnection(datasource);

		PreparedStatement stmt = con.prepareStatement("select \"agent\", \"resultid\", \"date\" , \"type\", \"xml\",  \"id\"  from claims where \"agent\" != 'inference' and \"date\" >= ?::timestamp and \"date\" <= ?::timestamp ");

		stmt.setTimestamp(1, new Timestamp(from.getTime()));

        stmt.setTimestamp(2, new Timestamp(to.getTime()));

		ResultSet rs = stmt.executeQuery();

		List<Claim> res = new ArrayList<Claim>();

		while (rs.next()) {

			res.add(new Claim(rs.getString(1), rs.getString(2), rs.getTimestamp(3).getTime(), rs.getString(4), rs.getString(5), rs.getString(6)));

		}

		rs.close();

		stmt.close();

		logger.debug("number of claims: " + res.size());

        logger.info("Returning " + res.size() + " claimed publications for date "  + from + "-" + to);

		return res;

	}

	public void deleteClaim(String userEmail, String id) throws SQLException {

        logger.info("Deleting claim with id " + id + " for agent " +  userEmail);

		Connection con = DataSourceUtils.getConnection(datasource);

        int claim_id = Integer.parseInt(id);

        String type = null;

		PreparedStatement stmt = con.prepareStatement("select \"resultid\", \"type\" from claims where \"id\" =?");

        stmt.setInt(1, claim_id);

        ResultSet rs = stmt.executeQuery();

        String resultid = null;

        String xml = null;

        while (rs.next()) {

            resultid = rs.getString("resultid");

            type = rs.getString("type");

        }

        if (resultid != null) {

            stmt = con.prepareStatement("delete from claims where \"agent\" =? and \"id\" =?");

            stmt.setString(1, userEmail);

            stmt.setInt(2, claim_id);

            stmt.executeUpdate();

            logger.info("Deleted claim with claim id: " + claim_id + ", result id: " + resultid + " and type: " + type +".") ;

            //prepare to get 2nd claim to be deleted

            int claim2_id = claim_id - 1;

            if (type != null && type.equals("rels2actions")) {

                con = DataSourceUtils.getConnection(datasource);

                stmt = con.prepareStatement("select \"type\", \"xml\" from claims where \"id\" =? and \"resultid\"=?");

                stmt.setInt(1, claim2_id);

                stmt.setString(2, resultid);

                rs = stmt.executeQuery();

                while (rs.next()) {

                    type = rs.getString("type");

                    xml = rs.getString("xml");

                }

                if(type!= null && type.equals("dmf2actions") && xml != null && !xml.contains("oaf:concept")) { //check if the relation has dmf

                    stmt =  con.prepareStatement("delete from claims where \"agent\" =? and \"id\" =? and \"resultid\" =? and \"type\" = ?");

                    stmt.setString(1, userEmail);

                    stmt.setInt(2, claim2_id);

                    stmt.setString(3, resultid);

                    stmt.setString(4, "dmf2actions");

                    stmt.executeUpdate();

                    logger.info("Deleted claim with id " + claim2_id + " and type: dmf2actions.");

                }

            } /*else if (type != null && type.equals("dmf2actions")) {

                logger.info("dmf2actions");

                con = DataSourceUtils.getConnection(datasource);

                stmt = con.prepareStatement("select \"type\", \"xml\" from claims where \"id\" =? and \"resultid\"=?");

                stmt.setInt(1, claim2_id);

                stmt.setString(2, resultid);

                rs = stmt.executeQuery();

                while (rs.next()) {

                    type = rs.getString("type");

                    xml = rs.getString("xml");

                }

                logger.info("xml: " + xml);

                logger.info("xml? " + xml.contains("oaf:concept"));

                if(type!= null && type.equals("dmf2actions") && xml != null && !xml.contains("oaf:concept")) { //delete concept with extra dmf (doi,orchid,... etc)

                    logger.debug("dmf2actions and not concept");

                    stmt =  con.prepareStatement("delete from claims where \"agent\" =? and \"id\" =? and \"resultid\" =? and \"type\" = ?");

                    stmt.setString(1, userEmail);

                    stmt.setInt(2, claim2_id);

                    stmt.setString(3, resultid);

                    stmt.setString(4, "dmf2actions");

                    stmt.executeUpdate();

                    logger.info("Deleted claim with id " + claim2_id + " and type: dmf2actions.");

                }

            }*/

        }

        stmt.close();

        logger.info("Deleted claim with id " + id + " for agent " +  userEmail);

	}

	/**

	 * @param id     {openaireId, publication doi, ORCIDId (personId-ORCIDPublicationId), data doi}

	 * @param source {openaire, doi (crossref), orcid, datacite}

	 * @throws ResourceNotFoundException

	 * @throws ParseErrorException

	 * @throws Exception

	 */

	public String insertDocument(

			String id,

			String source,

			String title,

			String description,

			String access_mode,

			String embargoEndDate,

			List<Author> authors,

			String url,

			String dcSource,

			String userEmail,

			List<String> subjects,

			String publicationDate,

			String publisher,

			String language,

			String category,

			String doi) throws Exception {

        logger.info("Request to insert document with id " + id + " and source " + source);

		String resultId;

		try {

			Connection con = DataSourceUtils.getConnection(datasource);

			PreparedStatement stmt;

			String dmf;

			resultId = ActionUtils.getIdentifier(ActionUtils.getPrefix(source), id);

			Date now = new Date();

			if (!source.toLowerCase().equals("openaire") && title != null) {

				stmt = con.prepareStatement("insert into claims (\"agent\", \"resultid\", \"date\", type, xml, set, provenance, nsprefix) values (?, ?, ?, ?, ?, ?, ?, ?)");

				dmf = ActionUtils.createDMF(id, source, title, description, access_mode, embargoEndDate, authors, url, dcSource, doi, Collections.EMPTY_LIST, subjects, Collections.EMPTY_LIST, publicationDate, publisher, language, category, false);

				stmt.setString(1, userEmail);

				stmt.setString(2, resultId);

				stmt.setTimestamp(3, new Timestamp(new Date().getTime()));

				stmt.setString(4, "dmf2actions");

				stmt.setString(5, dmf);

				stmt.setString(6, "userclaim_dmf");

				stmt.setString(7, ActionUtils.getProvenance(source));

				stmt.setString(8, ActionUtils.getPrefix(source));

				stmt.executeUpdate();

				stmt.close();

			}

		} catch (Exception e) {

			logger.error("Error inserting document", e);

			throw e;

		}

        logger.info("Inserted document with id " + id + ", source " + source + " and given resultId " + resultId);

		return resultId;

	}

	public void insertConceptRelation(String documentId, String documentSource, String concept, String userEmail, String doi) throws Exception {

        logger.info("Request for concept relation between document with id " + documentId + " with source " + documentSource + " and concept " + concept + "with doi " + doi);

		try {

			Connection con = DataSourceUtils.getConnection(datasource);

			PreparedStatement stmt;

			String dmf;

			stmt = con.prepareStatement("insert into claims (\"agent\", \"resultid\", \"date\", type, xml, set, provenance, nsprefix) values (?, ?, ?, ?, ?, ?, ?, ?)");

			dmf = ActionUtils.createDMF(documentId, documentSource, null, null, null, null, Collections.EMPTY_LIST, null, null, doi, Collections.EMPTY_LIST, Collections.EMPTY_LIST, Arrays.asList(concept), null, null, null, null, true);

			stmt.setString(1, userEmail);

			stmt.setString(2, documentId);

			stmt.setTimestamp(3, new Timestamp(new Date().getTime()));

			stmt.setString(4, "updates2actions");

			stmt.setString(5, dmf);

			stmt.setString(6, "userclaim_dmf");

			stmt.setString(7, ActionUtils.getProvenance(documentSource));

			stmt.setString(8, ActionUtils.getPrefix(documentSource));

			stmt.executeUpdate();

			stmt.close();

		} catch (Exception e) {

			logger.error("Error adding concept", e);

			throw e;

		}

        logger.info("Inserted concept relation between document with id " + documentId + " with source " + documentSource + " and concept " + concept);

	}

	public void insertProjectRelation(String docId, String documentSource, Project project, String userEmail) throws Exception {

        logger.info("Request for project relation between document with id " + docId + " with source " + documentSource + " and project " + project);

		try {

			Connection con = DataSourceUtils.getConnection(datasource);

			PreparedStatement stmt;

			String xml = ActionUtils.createResultProjectRelation("openaire".equals(documentSource) ? null : documentSource, docId, project.getType(), project.getProjectId());

			stmt = con.prepareStatement("insert into claims (\"agent\", \"resultid\", \"date\", type, xml, set, provenance, nsprefix) values (?, ?, ?, ?, ?, ?, ?, ?)");

			stmt.setString(1, userEmail);

			stmt.setString(2, docId);

			stmt.setTimestamp(3, new Timestamp(new Date().getTime()));

			stmt.setString(4, "rels2actions");

			stmt.setString(5, xml);

			stmt.setString(6, "userclaim_result_project");

			stmt.setString(7, ActionUtils.getProvenance(documentSource));

			stmt.setString(8, ActionUtils.getPrefix(documentSource));

			stmt.executeUpdate();

			stmt.close();

		} catch (Exception e) {

			logger.error("Error adding project", e);

			throw e;

		}

        logger.info("Inserted project relation between document with id " + docId + " with source " + documentSource + " and project " + project);

	}

	public void insertResultRelation(String sourceResultId, String sourceResultType, String sourceResultSource, String targetResultId, String targetResultType, String userEmail) throws Exception {

        logger.info("Request for result relation between source document with id " + sourceResultId + ", type " + sourceResultType + "and source " + sourceResultSource + " and " +

                "target document with id " + targetResultId + ", type " + targetResultType);

		try {

			Connection con = DataSourceUtils.getConnection(datasource);

			PreparedStatement stmt;

			String xml = ActionUtils.createResultResultRelation(sourceResultId, sourceResultType, targetResultId, targetResultType);

			stmt = con.prepareStatement("insert into claims (\"agent\", \"resultid\", \"date\", type, xml, set, provenance, nsprefix) values (?, ?, ?, ?, ?, ?, ?, ?)");

			stmt.setString(1, userEmail);

			stmt.setString(2, sourceResultId);

			stmt.setTimestamp(3, new Timestamp(new Date().getTime()));

			stmt.setString(4, "rels2actions");

			stmt.setString(5, xml);

			stmt.setString(6, "userclaim_result_result");

			stmt.setString(7, ActionUtils.getProvenance(sourceResultSource));

			stmt.setString(8, ActionUtils.getPrefix(sourceResultSource));

			stmt.executeUpdate();

			stmt.close();

		} catch (Exception e) {

			logger.error("Error adding result relation", e);

			throw e;

		}

        logger.info("Inserted result relation between source document with id " + sourceResultId + ", type " + sourceResultType + "and source " + sourceResultSource + " and " +

                "target document with id " + targetResultId + ", type " + targetResultType);

	}

	public DataSource getDatasource() {

		return datasource;

	}

	public void setDatasource(DataSource datasource) {

		this.datasource = datasource;

	}

	public ServiceLocator<ISLookUpService> getLookupServiceLocator() {

		return lookupServiceLocator;

	}

	public void setLookupServiceLocator(

			ServiceLocator<ISLookUpService> lookupServiceLocator) {

		this.lookupServiceLocator = lookupServiceLocator;

	}

	public List<String> getContexts() throws ISLookUpException, ISLookUpServiceException {

		return lookupServiceLocator.getService().quickSearchProfile("for $x in collection('/db/DRIVER/ContextDSResources/ContextDSResourceType') return $x");

	}

}

package eu.dnetlib.openaire.thrift;

import eu.dnetlib.api.functionality.AlertService;

import eu.dnetlib.api.functionality.AlertServiceException;

import gr.uoa.di.driver.util.ServiceLocator;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.List;

public class AlertConnector {

	private ServiceLocator<AlertService> alertServiceLocator;

	public void setAlertServiceLocator(

			final ServiceLocator<AlertService> alertServiceLocator) {

		this.alertServiceLocator = alertServiceLocator;

	}

	public List<AlertSubscription> getSubscriptions(final String alertMode,

			final String subscriber, final int limit, final int offset)

			throws AlertServiceException {

		final List<AlertSubscription> subscriptions = new ArrayList<AlertSubscription>();

		for (eu.dnetlib.domain.functionality.AlertSubscription subscription : alertServiceLocator

				.getService().getSubscriptions(alertMode, subscriber, limit,

						offset))

			subscriptions.add(new AlertSubscription(subscription

					.getTemplateId(), subscription.getNotificationService()

					.toString(), subscription.getQueryId(), subscription

					.getResultId(), subscription.getAlertMode(), subscription

					.getSubscriber().toString()));

		return subscriptions;

	}

	public void addSubscription(final AlertSubscription subscription)

			throws AlertServiceException, MalformedURLException,

			URISyntaxException {

		alertServiceLocator.getService().addSubscription(

				new eu.dnetlib.domain.functionality.AlertSubscription(

						subscription.getTemplateId(), new URL(subscription

								.getNotificationService()), subscription

								.getQueryId(), subscription.getResultId(),

						subscription.getAlertMode(), new URI(subscription

								.getSubscriber()), true));

	}

	public void removeSubscription(final AlertSubscription subscription)

			throws AlertServiceException, MalformedURLException,

			URISyntaxException {

		alertServiceLocator.getService().removeSubscription(

				subscription.getTemplateId(),

				new URL(subscription.getNotificationService()),

				subscription.getQueryId(), subscription.getResultId(),

				subscription.getAlertMode(),

				new URI(subscription.getSubscriber()));

	}

	public int countAlertResults(final String notificationService,

			final String queryId, final long date, final String resultId)

			throws AlertServiceException, MalformedURLException {

		return alertServiceLocator.getService()

				.countAlertResults(new URL(notificationService), queryId,

						new Date(date), resultId);

	}

	public ResultPage getAlertResults(final String notificationService,

			final String queryId, final String resultId, final long fromDate,

			final long toDate, final int limit, final int offset)

			throws AlertServiceException, MalformedURLException {

		final eu.dnetlib.domain.functionality.ResultPage resultPage = alertServiceLocator

				.getService().getAlertResults(new URL(notificationService),

						queryId, resultId, new Date(fromDate),

						new Date(toDate), limit, offset);

		final List<List<String>> rows = new ArrayList<List<String>>();

		for (String[] row : resultPage.getRows())

			rows.add(Arrays.asList(row));

		return new ResultPage(resultPage.getLimit(), resultPage.getOffset(),

				Arrays.asList(resultPage.getColumns()), rows);

	}

}

<?xml version="1.0"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

	<parent>

		<groupId>eu.dnetlib</groupId>

		<artifactId>dnet-parent</artifactId>

		<version>1.0.0</version>

	</parent>

	<modelVersion>4.0.0</modelVersion>

	<groupId>eu.dnetlib</groupId>

	<artifactId>uoa-openaire-connector</artifactId>

	<version>1.3.1-SNAPSHOT</version>

        <scm>

                <developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-openaire-connector/trunk</developerConnection>

        </scm>

	<pluginRepositories>

		<pluginRepository>

			<id>dtrotts</id>

			<name>Repository for maven thrift plugin</name>

			<url>http://maven.davidtrott.com/repository</url>

			<layout>default</layout>

		</pluginRepository>

	</pluginRepositories>

	<build>

		<plugins>

			<plugin>

				<artifactId>maven-assembly-plugin</artifactId>

				<configuration>

					<archive>

					</archive>

					<descriptorRefs>

						<descriptorRef>jar-with-dependencies</descriptorRef>

					</descriptorRefs>

				</configuration>

			</plugin>

			<plugin>

				<groupId>org.apache.thrift.tools</groupId>

				<artifactId>maven-thrift-plugin</artifactId>

				<version>0.1.10</version>

				<executions>

					<execution>

						<id>thrift-sources</id>

						<phase>generate-sources</phase>

						<goals>

							<goal>compile</goal>

						</goals>

					</execution>

					<execution>

						<id>thrift-test-sources</id>

						<phase>generate-test-sources</phase>

						<goals>

							<goal>testCompile</goal>

						</goals>

					</execution>

				</executions>

			</plugin>

		</plugins>

		<pluginManagement>

			<plugins>

				<!--This plugin's configuration is used to store Eclipse m2e settings 

					only. It has no influence on the Maven build itself. -->

				<plugin>

					<groupId>org.eclipse.m2e</groupId>

					<artifactId>lifecycle-mapping</artifactId>

					<version>1.0.0</version>

					<configuration>

						<lifecycleMappingMetadata>

							<pluginExecutions>

								<pluginExecution>

									<pluginExecutionFilter>

										<groupId>org.apache.thrift.tools</groupId>

										<artifactId>maven-thrift-plugin</artifactId>

										<versionRange>[0.1.10,)</versionRange>

										<goals>

											<goal>testCompile</goal>

										</goals>

									</pluginExecutionFilter>

									<action>

										<ignore />

									</action>

								</pluginExecution>

							</pluginExecutions>

						</lifecycleMappingMetadata>

					</configuration>

				</plugin>

			</plugins>

		</pluginManagement>

	</build>

	<dependencies>

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

			<version>[0.0.0,)</version>

			<scope>test</scope>

		</dependency>