D-Net

<?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-validator</artifactId>

	<packaging>jar</packaging>

	<version>1.0.1</version>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-validator/tags/uoa-validator-1.0.1</developerConnection>

	</scm>

	<dependencies>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>uoa-clients</artifactId>

			<version>[1.0.0]</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>uoa-utils</artifactId>

			<version>[1.0.0]</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>uoa-api</artifactId>

			<version>[1.0.0]</version>

		</dependency>

		<dependency>

			<groupId>apache</groupId>

			<artifactId>commons-io</artifactId>

			<version>[1.4,)</version>

		</dependency>

		<dependency>

			<groupId>apache</groupId>

			<artifactId>commons-cli</artifactId>

			<version>[1.0,)</version>

		</dependency>

		<dependency>

			<groupId>log4j</groupId>

			<artifactId>log4j</artifactId>

			<version>[1.2.14,1.3.0)</version>

		</dependency>

		<dependency>

			<groupId>com.thoughtworks.xstream</groupId>

			<artifactId>xstream</artifactId>

			<version>[0.0.0,)</version>

		</dependency>

		<dependency>

			<groupId>junit</groupId>

			<artifactId>junit</artifactId>

			<version>[0.0.0,)</version>

			<scope>test</scope>

		</dependency>

		<dependency>

			<groupId>org.springframework</groupId>

			<artifactId>spring-jdbc</artifactId>

			<version>${spring.version}</version>

		</dependency>

		<dependency>

			<groupId>org.springframework</groupId>

			<artifactId>spring-tx</artifactId>

			<version>${spring.version}</version>

		</dependency>

		<dependency>

			<groupId>org.apache.velocity</groupId>

			<artifactId>velocity</artifactId>

			<version>1.7</version>

		</dependency>

		<dependency>

			<groupId>eu.dnetlib</groupId>

			<artifactId>cnr-blackboard-common</artifactId>

			<version>[1.0.0]</version>

		</dependency>

		<dependency>

			<groupId>postgresql</groupId>

			<artifactId>postgresql</artifactId>

			<version>9.1-901.jdbc4</version>

		</dependency>

		<dependency>

			<groupId>se.kb</groupId>

			<artifactId>oai4j</artifactId>

			<version>[0.6b1,)</version>

		</dependency>

	</dependencies>

</project>

{

  "type_source": "SVN", 

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

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

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

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

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

  "name": "uoa-validator"

}

<?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:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core" xmlns:jaxws="http://cxf.apache.org/jaxws"

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

	xmlns:template="http://dnetlib.eu/springbeans/template" xmlns:t="http://dnetlib.eu/springbeans/t"

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

	xsi:schemaLocation="

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

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

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

        http://dnetlib.eu/springbeans/template http://dnetlib.eu/springbeans/template.xsd"

	default-autowire="no">

	<bean id="blackboardHandler"

		class="eu.dnetlib.enabling.tools.blackboard.BlackboardHandlerImpl">

		<property name="registryLocator" ref="cnr.registryLocator" />

		<property name="messageFactory">

			<bean class="eu.dnetlib.miscutils.jaxb.JaxbFactory">

				<constructor-arg

					value="eu.dnetlib.enabling.tools.blackboard.BlackboardMessageImpl" />

			</bean>

		</property>

	</bean>

	<bean id="notificationListener" class="gr.uoa.di.validator.service.NotificationListener"

		scope="singleton">

		<property name="valManager" ref="validatorManager" />

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

	</bean>

	<bean id="validatorManager" class="gr.uoa.di.validator.service.ValidatorManagerImpl"

		scope="singleton" init-method="start">

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

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

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

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

		<lookup-method name="createListener" bean="openaireValListener" />

		<lookup-method name="createDnetListener" bean="openaireDnetListener" />

	</bean>

	<bean id="validatorService" class="gr.uoa.di.validator.service.ValidatorServiceImpl"

		scope="singleton">

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

		<property name="blackboardNotificationHandler" ref="notificationListener" />

	</bean>

<!-- 	<bean id="dnetProvider" class="gr.uoa.di.validator.service.DnetProvider" factory-method="getInstance"> -->

<!-- 		<property name="dataSourceResolver" ref="extendedDataSourceResolver" /> -->

<!-- 		<property name="rsFactory" ref="resultSetFactory" /> -->

<!-- 	</bean> -->

	<!-- The web service bean -->

	<bean id="validatorWebServiceImpl"

		class="eu.dnetlib.clients.functionality.validator.ws.ValidatorWebServiceImpl">

		<property name="service" ref="validatorService" />

	</bean>

	<!-- Service endpoint -->

	<jaxws:endpoint 

		id="validatorWebService" 

		implementor="#validatorWebServiceImpl"

		implementorClass="eu.dnetlib.clients.functionality.validator.ws.ValidatorWebService"

		address="/validatorWebService"/>

	<template:instance name="nkua.serviceRegistrationManager"

		t:name="validatorServiceRegistrationManager"

		t:service="validatorService"

		t:endpoint="validatorWebService"/>

</beans>

<?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:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core" xmlns:jaxws="http://cxf.apache.org/jaxws"

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

	xmlns:template="http://dnetlib.eu/springbeans/template" xmlns:t="http://dnetlib.eu/springbeans/t"

	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/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

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

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

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

        http://dnetlib.eu/springbeans/template http://dnetlib.eu/springbeans/template.xsd"

	default-autowire="no">

	<bean id="jobSubmittedDao" class="gr.uoa.di.validator.dao.JobSubmittedDAOImpl">

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

	</bean>

	<bean id="repositoryStoredDao" class="gr.uoa.di.validator.dao.RepositoryStoredDAOImpl">

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

	</bean>

	<bean id="ruleSetDao" class="gr.uoa.di.validator.dao.RuleSetDAOimpl">

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

	</bean>	

	<bean id="ruleStoredDao" class="gr.uoa.di.validator.dao.RuleStoredDAOimpl">

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

	</bean>		

	<bean id="taskStoredDao" class="gr.uoa.di.validator.dao.TaskStoredDAOimpl">

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

	</bean>		

	<bean id="userStoredDao" class="gr.uoa.di.validator.dao.UserStoredDAOimpl">

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

	</bean>				

</beans>

services.validator.db.driverClassName = org.postgresql.Driver

services.validator.db.url = jdbc:postgresql://194.177.192.223:5432/validatornew

services.validator.db.username = nickonas

services.validator.db.password = 123456

<?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:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core"

	xmlns:jaxws="http://cxf.apache.org/jaxws"

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

	xmlns:template="http://dnetlib.eu/springbeans/template"

	xmlns:t="http://dnetlib.eu/springbeans/t"

	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/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

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

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

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

        http://dnetlib.eu/springbeans/template http://dnetlib.eu/springbeans/template.xsd"

	default-autowire="no">

	<bean id="validator.dataSource" class="org.apache.commons.dbcp.BasicDataSource"

		destroy-method="close">

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

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

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

		<property name="password" value="${services.validator.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="testWhileIdle" value="true" />

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

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

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

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

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

		<property name="removeAbandonedTimeout" value="60" />

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

	</bean>

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

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

	</bean>

	<tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>

</beans>

services.validator.engine.timeout=3600

services.validator.engine.generalTimeout=86400

services.validator.engine.poolExecutor.corePoolSize=20

services.validator.engine.poolExecutor.maximumPoolSize=40

services.validator.engine.poolExecutor.keepAliveTime=3600

services.validator.baseUrl = localhost

<?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:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core"

	xmlns:jaxws="http://cxf.apache.org/jaxws"

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

	xmlns:template="http://dnetlib.eu/springbeans/template"

	xmlns:t="http://dnetlib.eu/springbeans/t"

	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/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

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

        http://dnetlib.eu/springbeans/template http://dnetlib.eu/springbeans/template.xsd"

	default-autowire="no">

	<bean id ="openaireValListener" class="gr.uoa.di.validator.impls.listeners.ValidatorJobListener" scope="prototype">

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

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

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

		<property name="valBaseUrl" value="${services.validator.baseUrl}" />

	</bean>

	<bean id ="openaireDnetListener" class="gr.uoa.di.validator.impls.listeners.DnetListener" scope="prototype" init-method="init">	

		<property name="xmlBuilder" ref="recordXMLBuilder" />

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

	</bean>

	<bean id ="recordXMLBuilder" class="gr.uoa.di.validator.impls.listeners.RecordXMLBuilder" init-method="init" scope="prototype" />

</beans>

<?xml version="1.0"?>

<validator:result xmlns:validator="http://eu.dnetlib/validator" recordId=$record.id status=$record.status score=$record.score>

  <validator:failedRules>

#foreach( $rule in $ruleList )

    <validator:rule id=$rule.id errorMessage=$rule.error/>

#end

  </validator:failedRules>

  <validator:record>

  	$recordFull

  </validator:record>

</validator:result>

<?xml version="1.0"?>

<validator:jobResult xmlns:validator="http://eu.dnetlib/validator" recordId=$record.id status=$record.status score=$record.score>

    <validator:startDate startDate=$job.startDate/>

    <validator:endDate endDate=$job.endDate />

    <validator:duration duration=$job.duration />

    <validator:totalRecords totalRecords=$job.totalRecords />

    <validator:passedRecords passedRecords=$job.passedRecords />

    <validator:failedRecords failedRecords=$job.failedRecords />

    <validator:score score=$job.score />

</validator:jobResult>

<?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:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core" xmlns:jaxws="http://cxf.apache.org/jaxws"

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

	xmlns:template="http://dnetlib.eu/springbeans/template" xmlns:t="http://dnetlib.eu/springbeans/t"

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

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

	xsi:schemaLocation="

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

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

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

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

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd

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

        http://dnetlib.eu/springbeans/template http://dnetlib.eu/springbeans/template.xsd"

	default-autowire="no">

	<bean id="validator" class="gr.uoa.di.validator.impls.MemoryThreadValidator" init-method="start">

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

		<property name="rsFactory" ref="resultSetFactory" />

		<property name="dnetWorkflow" value="${services.validator.dnetWorkflow}" />

<!-- 		<property name="dnetWorkflow" value="true" /> -->

		<constructor-arg index="0" ref="persistance" />

		<constructor-arg index="1" ref="threadPoolExecutor" />

		<constructor-arg index="2" ref="taskExecutor" />

		<constructor-arg index="3" value="${services.validator.engine.timeout}" />

		<constructor-arg index="4" value="${services.validator.engine.generalTimeout}" />

	</bean>

<!-- 	<bean id="extendedDataSourceResolver" -->

<!-- 		class="eu.dnetlib.data.information.DataSourceResolverDispatcher"> -->

<!-- 		<property name="resolvers"> -->

<!-- 			<map> -->

<!-- 				<entry key="EPR"> -->

<!-- 					<bean class="eu.dnetlib.data.information.EPRDataSourceResolverImpl"> -->

<!-- 					</bean> -->

<!-- 				</entry> -->

<!-- 			</map> -->

<!-- 		</property> -->

<!-- 	</bean> -->

	<bean id="persistance" class ="gr.uoa.di.validator.impls.persistance.XMLFilePersistance">

		<constructor-arg index="0">

			<props>

                <prop key="directory">output</prop>

            </props>

        </constructor-arg> 

    </bean>

	<bean id="taskExecutor" class="gr.uoa.di.validator.impls.executors.ThreadExecutor">

		<constructor-arg index="0" ref="threadPoolExecutor"/>

	</bean>

	<bean id="threadPoolExecutor" class="java.util.concurrent.ThreadPoolExecutor" >

		<constructor-arg index="0" value="${services.validator.engine.poolExecutor.corePoolSize}" />

		<constructor-arg index="1" value="${services.validator.engine.poolExecutor.maximumPoolSize}" />

		<constructor-arg index="2" value="${services.validator.engine.poolExecutor.keepAliveTime}" />

		<constructor-arg index="3"><util:constant static-field="java.util.concurrent.TimeUnit.SECONDS"/></constructor-arg>

		<constructor-arg index="4">

			<bean class="java.util.concurrent.LinkedBlockingQueue"/>

		</constructor-arg>					

	</bean>	

</beans>

package gr.uoa.di.validator.persistance;

import gr.uoa.di.validator.Validator;

import java.io.Serializable;

/**

 * A Registry used to store serializable objects.

 * Registries are used by {@link Validator} to store the objects they need to run.

 * @author Manos Karvounis

 *

 * @param <T>

 */

public abstract class Registry<T extends Serializable> {

	public final String name;

	public Registry(String name) {

		super();

		this.name = name;

	}

	public abstract T getObject(int id);

	public abstract void addObject(int id, T obj);

}

package gr.uoa.di.validator.persistance;

import gr.uoa.di.validator.data.DataException;

/**

 * Indicates that an object may be persisted to permanent storage and be retrieved from it.

 * @author manos

 *

 */

public interface Persistable {

	public void persist() throws DataException;

	public void restore() throws DataException;

}

package gr.uoa.di.validator.persistance;

import gr.uoa.di.validator.data.DataException;

import gr.uoa.di.validator.data.ResultSet;

import java.io.Serializable;

/**

 * A mechainism for persisting/retrieving Serializable objects to/from permanent storage.

 * @author Manos Karvounis

 *

 */

public interface Persistance {

	/**

	 * Initialize the mechanism. Must be invoked before any other method is invoked.

	 * @throws DataException

	 */

	public void open() throws DataException;

	/**

	 * Close the mechanism and release all held resources.

	 * Must be invoked even if a an exception was raised by another method.

	 * @throws DataException

	 */

	public void close() throws DataException;

	/**

	 * Persists a serializable object to permanent storage.

	 * @param <T>

	 * @param objid A unique id identifying the object.

	 * @param obj The object itself.

	 * @param container The name of the container where the object will be stored. Note that objects are restored as a whole from their container {@link Persistance#restore(String)

	 * @throws DataException

	 */

	public <T extends Serializable> void persist(int objid, T obj, String container) throws DataException;

	/**

	 * Restore all the contents of a container. 

	 * @param <T>

	 * @param container The name of the container.

	 * @return The objects contained in the container.

	 * @throws DataException

	 */

	public <T extends Serializable> ResultSet<T> restore(String container) throws DataException;

}

package gr.uoa.di.validator.service;

import eu.dnetlib.enabling.tools.blackboard.BlackboardJob;

import eu.dnetlib.enabling.tools.blackboard.BlackboardNotificationHandler;

import eu.dnetlib.enabling.tools.blackboard.BlackboardServerHandler;

import gr.uoa.di.validator.ValidatorException;

import gr.uoa.di.validator.dao.JobSubmitted;

public interface ValidatorManager {

	public JobSubmitted beginDataJobForWorkflow(String datasource, String guidelines, String groupBy, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler, int workers) throws ValidatorException;

	public JobSubmitted beginContentJobForWorkflow(String baseUrl, String validationSet, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler) throws ValidatorException;

	public JobSubmitted beginUsageJobForWorkflow(String baseUrl, String validationSet, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler) throws ValidatorException;

}

package gr.uoa.di.validator.service;

import eu.dnetlib.enabling.tools.blackboard.BlackboardJob;

import eu.dnetlib.enabling.tools.blackboard.BlackboardNotificationHandler;

import eu.dnetlib.enabling.tools.blackboard.BlackboardServerHandler;

import gr.uoa.di.validator.Validator;

import gr.uoa.di.validator.ValidatorException;

import gr.uoa.di.validator.dao.JobSubmitted;

import gr.uoa.di.validator.dao.JobSubmittedDAO;

import gr.uoa.di.validator.dao.RuleSet;

import gr.uoa.di.validator.dao.RuleSetDAO;

import gr.uoa.di.validator.dao.RuleStored;

import gr.uoa.di.validator.dao.RuleStoredDAO;

import gr.uoa.di.validator.dao.Utilities;

import gr.uoa.di.validator.data.Rule;

import gr.uoa.di.validator.execution.Job;

import gr.uoa.di.validator.impls.MemoryThreadValidator;

import gr.uoa.di.validator.impls.listeners.DnetListener;

import gr.uoa.di.validator.impls.listeners.ValidatorJobListener;

import gr.uoa.di.validator.impls.providers.OAIPMHRecordProvider;

import gr.uoa.di.validator.impls.providers.OAIPMHSinglePageVerbProvider;

import gr.uoa.di.validator.impls.rules.ChainRule;

import gr.uoa.di.validator.impls.rules.RuleTypes;

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

import org.apache.log4j.Logger;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

@Transactional(propagation = Propagation.REQUIRED)

public abstract class ValidatorManagerImpl implements ValidatorManager {

	private Validator validator;

	private JobSubmittedDAO jobSubmittedDao;

	private RuleSetDAO ruleSetDao;

	private RuleStoredDAO ruleStoredDao;

//	private Map<Integer, Integer> ruleLinkingMap = new HashMap<Integer, Integer>();

	private Integer jobIdRegistry = 1;

	private Integer ruleIdRegistry = 1;

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

	protected abstract ValidatorJobListener createListener();

	protected abstract DnetListener createDnetListener();

	public void start() {

		logger.debug("Initializing Validator Manager module");

	}

	@Transactional(propagation = Propagation.REQUIRED)

	public JobSubmitted beginDataJobForWorkflow(String mdstoreId, String guidelines, String groupBy, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler, int workers) throws ValidatorException{

		try {

			logger.debug("Submitting data job for workflow");

//			String desiredCompatibility = "openaire3.0";

			Set<Integer> ruleIdsContent = new HashSet<Integer>();

			for (RuleSet ruleset : ruleSetDao.getRuleSets()) {

				if (ruleset.getGuidelinesAcronym().equals(guidelines)) {

					ruleIdsContent = Utilities.convertListToSet(ruleset.getRuleIdsContent());

				}	

			}

			Properties pros = new Properties();

			pros.setProperty(DnetProvider.MDSTORE_ID, mdstoreId);

//			pros.setProperty(DnetProvider.BATCH_SIZE, bJob.getParameters().get("batchSize"));

			pros.setProperty(DnetProvider.BATCH_SIZE, "50");

			pros.setProperty(DnetProvider.RECORDS, bJob.getParameters().get("records"));

			JobSubmitted newJob = new JobSubmitted();

			Set<Integer> rules = new HashSet<Integer>();

			Map<Integer,Integer> ruleLinkingMap = new HashMap<Integer,Integer>();

			for (Integer ruleId : ruleIdsContent) {

				RuleStored tempRule=ruleStoredDao.get(ruleId.toString());

				//special behaviour type of rule is chain

				if(tempRule.getType().equals("ChainRule")) {

					ChainRule<Rule> chainRule = this.handleChain(tempRule);

					validator.addToRegistry(ruleIdRegistry,chainRule, MemoryThreadValidator.RegistryType.rules);					

				}

				else {

					validator.addToRegistry(ruleIdRegistry,this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), ruleIdRegistry), MemoryThreadValidator.RegistryType.rules);

				}

				rules.add(ruleIdRegistry);

//				this.linkRules(ruleIdRegistry, ruleId);

				ruleLinkingMap.put(ruleIdRegistry, ruleId);

				ruleIdRegistry++;

			}

			Job job = new Job(this.jobIdRegistry, 3, rules, pros);

			this.jobIdRegistry++;

			newJob.setUser("Workflow Service");

			newJob.setValidationType("OAI Content");

			newJob.setGuidelines(guidelines);

//			newJob.setType("OAI Content Validation");

			newJob.setStatus("working");

			newJob.setJobType("Workflow Request");

			newJob.setDuration("--");

			newJob.setRepo(mdstoreId);

			newJob.setRules(ruleIdsContent);

			newJob.setRecords(pros.getProperty(DnetProvider.RECORDS));

			newJob.setSet("dnet-workflow");

			newJob.setGroupBy_xpath(groupBy);

			newJob.setMetadata_prefix("oai_dc");

			newJob.setId("-1");

			int jobIdStored = jobSubmittedDao.save(newJob);

			ValidatorJobListener listener = createListener();

			listener.setJobSubmittedId(jobIdStored);

			listener.setJobSubmittedUser("Workflow Service");

			listener.setRuleLinkingMap(ruleLinkingMap);

			listener.setGroupBy_xpath(groupBy);

			listener.setInternalJobsSum(workers);

//			

			DnetListener dnetListener = createDnetListener();

			dnetListener.setJob(bJob);

			dnetListener.setBlackboardHandler(blackboardHandler);

//			validator.submitJob(job, listener, dnetListener);

			validator.submitJob(job, workers, listener, dnetListener);

			return newJob;

		} catch (Exception e) {

			logger.error("Error Submitting content job", e);

			throw new ValidatorException(e);

		}

	}

/*	public JobSubmitted beginDataJobForWorkflow(String mdstoreId, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler) throws ValidatorException{

		try {

			logger.debug("Submitting data job for workflow");

			Set<Integer> ruleIdsContent = new HashSet<Integer>();

			for (RuleSet ruleset : ruleSetDao.getRuleSets()) {

				String regRuleset;

				regRuleset = "OpenAIRE For Literature Repositories";

				if (ruleset.getName().equals(regRuleset)) {

					ruleIdsContent = Utilities.convertListToSet(ruleset.getRuleIdsContent());

				}

			}

			Properties pros = new Properties();

			pros.setProperty(DnetProvider.MDSTORE_ID, mdstoreId);

			pros.setProperty(DnetProvider.BATCH_SIZE, "10");

			pros.setProperty(DnetProvider.RECORDS, "5");

			JobSubmitted newJob = new JobSubmitted();

			Set<Integer> rules = new HashSet<Integer>();

			for (Integer ruleId : ruleIdsContent) {

				RuleStored tempRule = ruleStoredDao.get(ruleId.toString());

				// special behaviour type of rule is chain

				if (tempRule.getType().equals("ChainRule")) {

					logger.debug("chain rule found");

					RuleStored tempRuleChain1 = ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_1"));

					RuleStored tempRuleChain2 = ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_2"));

					List<Rule> rules_chain = new ArrayList<Rule>();

					rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain1.getType(), tempRuleChain1.getConfiguration(), ruleIdRegistry));

					ruleIdRegistry++;

					rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain2.getType(), tempRuleChain2.getConfiguration(), ruleIdRegistry));

					ruleIdRegistry++;

					Properties chainPros = new Properties();

					chainPros.setProperty(ChainRule.TYPE, tempRule.getConfiguration().getProperty(ChainRule.TYPE));

					ChainRule<Rule> chainRule = new ChainRule<Rule>(chainPros, ruleIdRegistry, rules_chain);

					validator.addToRegistry(ruleIdRegistry, chainRule, MemoryThreadValidator.RegistryType.rules);

				} else {

					validator.addToRegistry(ruleIdRegistry, this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), ruleIdRegistry), MemoryThreadValidator.RegistryType.rules);

				}

				rules.add(ruleIdRegistry);

				this.linkRules(ruleIdRegistry, ruleId);

				ruleIdRegistry++;

			}

			Job job = new Job(this.jobIdRegistry, 3, rules, pros);

			this.jobIdRegistry++;

			newJob.setUser("Workflow Service");

			newJob.setValidationType("OAI Content");

//			newJob.setType("OAI Content Validation");

			newJob.setStatus("working");

			newJob.setJobType("Workflow Request");

//			newJob.setRuleset("Workflow Request");

			//TODO FIX

			newJob.setGuidelines("OpenAIRE For Literature Repositories");

			newJob.setActivation_id(null);

			newJob.setDuration("--");

			newJob.setRepo(mdstoreId);

			newJob.setRules(ruleIdsContent);

			newJob.setRecords(pros.getProperty(DnetProvider.RECORDS));

			newJob.setSet("dnet-workflow");

			newJob.setGroupBy_xpath(null);

			newJob.setMetadata_prefix("");

			newJob.setId("-1");

			int jobIdStored = jobSubmittedDao.save(newJob);

			ValidatorJobListener listener = createListener();

			listener.setJobSubmittedId(jobIdStored);

			listener.setJobSubmittedUser("Workflow Service");

			listener.setRuleLinkingMap(ruleLinkingMap);

			listener.setGroupBy_xpath(null);

			listener.setInternalJobsSum(1);

			DnetListener dnetListener = createDnetListener();

			dnetListener.setJob(bJob);

			dnetListener.setBlackboardHandler(blackboardHandler);

			validator.submitJob(job, listener, dnetListener);

			return newJob;

		} catch (Exception e) {

			logger.error("Error Submitting content job for workflow", e);

			throw new ValidatorException(e);

		}

	} */

	@Override

	public JobSubmitted beginContentJobForWorkflow(String baseUrl, String validationSet, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler) throws ValidatorException {

		try {

			logger.debug("Submitting content job for workflow");

			Set<Integer> ruleIdsContent = new HashSet<Integer>();

			for (RuleSet ruleset : ruleSetDao.getRuleSets()) {

				String regRuleset;

				if (validationSet.equalsIgnoreCase("openaire_data")) {

					regRuleset = "OpenAIRE For Data Archives";

				} else {

					regRuleset = "OpenAIRE For Literature Repositories";

				}

				if (ruleset.getName().equals(regRuleset)) {

					ruleIdsContent = Utilities.convertListToSet(ruleset.getRuleIdsContent());

				}

			}

			Properties pros = null;

			pros = new Properties();

			pros.setProperty(OAIPMHRecordProvider.BASEURL, baseUrl);

			pros.setProperty(OAIPMHRecordProvider.METADATA_PREFIX, "oai_dc");

			pros.setProperty(OAIPMHRecordProvider.TIMEOUT, "360000");

			pros.setProperty(OAIPMHRecordProvider.DELAY, "1000");

			pros.setProperty(OAIPMHRecordProvider.RETRY_DELAY, "60000");

			pros.setProperty(OAIPMHRecordProvider.RETRY_EFFORTS, "3");

			// pros.setProperty(OAIPMHRecordProvider.RECORDS, "20");

			pros.setProperty(OAIPMHRecordProvider.RECORDS, "all");

			pros.setProperty(OAIPMHRecordProvider.SET, validationSet);

			JobSubmitted newJob = new JobSubmitted();

			Set<Integer> rules = new HashSet<Integer>();

			Map<Integer,Integer> ruleLinkingMap = new HashMap<Integer,Integer>();

			for (Integer ruleId : ruleIdsContent) {

				RuleStored tempRule = ruleStoredDao.get(ruleId.toString());

				// special behaviour type of rule is chain

				if (tempRule.getType().equals("ChainRule")) {

					logger.debug("chain rule found");

					RuleStored tempRuleChain1 = ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_1"));

					RuleStored tempRuleChain2 = ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_2"));

					List<Rule> rules_chain = new ArrayList<Rule>();

					rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain1.getType(), tempRuleChain1.getConfiguration(), ruleIdRegistry));

					ruleIdRegistry++;

					rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain2.getType(), tempRuleChain2.getConfiguration(), ruleIdRegistry));

					ruleIdRegistry++;

					Properties chainPros = new Properties();

					chainPros.setProperty(ChainRule.TYPE, tempRule.getConfiguration().getProperty(ChainRule.TYPE));

					ChainRule<Rule> chainRule = new ChainRule<Rule>(chainPros, ruleIdRegistry, rules_chain);

					validator.addToRegistry(ruleIdRegistry, chainRule, MemoryThreadValidator.RegistryType.rules);

				} else {

					validator.addToRegistry(ruleIdRegistry, this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), ruleIdRegistry), MemoryThreadValidator.RegistryType.rules);

				}

				rules.add(ruleIdRegistry);

//				this.linkRules(ruleIdRegistry, ruleId);

				ruleLinkingMap.put(ruleIdRegistry, ruleId);

				ruleIdRegistry++;

			}

			if (pros.getProperty(OAIPMHRecordProvider.SET).equalsIgnoreCase(

					"openaire_data"))

				pros.setProperty(OAIPMHRecordProvider.METADATA_PREFIX,

						"oai_datacite");

			Job job = new Job(this.jobIdRegistry, 1, rules, pros);

			this.jobIdRegistry++;

			newJob.setUser("Workflow Service");

			newJob.setValidationType("OAI Content");

//			newJob.setType("OAI Content Validation");

			newJob.setStatus("working");

			newJob.setJobType("Workflow Request");

			//TODO FIX

			newJob.setGuidelines("OpenAIRE For Literature Repositories");

			newJob.setActivation_id(null);

			newJob.setDuration("--");

			newJob.setRepo(baseUrl);

			newJob.setRules(ruleIdsContent);

			newJob.setRecords(pros.getProperty(OAIPMHRecordProvider.RECORDS));

			newJob.setSet(pros.getProperty(OAIPMHRecordProvider.SET));

			newJob.setGroupBy_xpath(null);

			newJob.setMetadata_prefix(pros.getProperty(OAIPMHRecordProvider.METADATA_PREFIX));

			newJob.setId("-1");

			int jobIdStored = jobSubmittedDao.save(newJob);

			ValidatorJobListener listener = createListener();

			listener.setJobSubmittedId(jobIdStored);

			listener.setJobSubmittedUser("Workflow Service");

			listener.setRuleLinkingMap(ruleLinkingMap);

			listener.setGroupBy_xpath(null);

			listener.setInternalJobsSum(1);

			DnetListener dnetListener = createDnetListener();

			dnetListener.setJob(bJob);

			dnetListener.setBlackboardHandler(blackboardHandler);

			validator.submitJob(job, 1, listener, dnetListener);

			return newJob;

		} catch (Exception e) {

			logger.error("Error Submitting content job for workflow", e);

			throw new ValidatorException(e);

		}

	}

	@Override

	public JobSubmitted beginUsageJobForWorkflow(String baseUrl, String validationSet, BlackboardJob bJob, BlackboardNotificationHandler<BlackboardServerHandler> blackboardHandler) throws ValidatorException {

		try {

			logger.debug("Submitting Usage job(s) for workflow");

			Set<Integer> ruleIdsUsage = new HashSet<Integer>();

			for (RuleSet ruleset : ruleSetDao.getRuleSets()) {

				String regRuleset;

				if (validationSet.equalsIgnoreCase("openaire_data")) {

					regRuleset = "OpenAIRE For Data Archives";

				} else {

					regRuleset = "OpenAIRE For Literature Repositories";

				}

				if (ruleset.getName().equals(regRuleset)) {

					ruleIdsUsage = Utilities.convertListToSet(ruleset

							.getRuleIdsUsage());

				}

			}

			Properties pros = new Properties();

			pros.setProperty(OAIPMHSinglePageVerbProvider.BASEURL, baseUrl);

			pros.setProperty(OAIPMHSinglePageVerbProvider.TIMEOUT, "360000");

			pros.setProperty(OAIPMHSinglePageVerbProvider.DELAY, "1000");

			pros.setProperty(OAIPMHSinglePageVerbProvider.RETRY_DELAY, "60000");

			pros.setProperty(OAIPMHSinglePageVerbProvider.RETRY_EFFORTS, "3");

			JobSubmitted newJob = new JobSubmitted();

			List<RuleStored> rulesStored = new ArrayList<RuleStored>();

			for (Integer id : ruleIdsUsage) {

				logger.debug("Rule with id: " + id + " added");

				rulesStored.add(ruleStoredDao.get(id.toString()));

			}

			logger.debug("Creating map for provider information");

			Map<String, Set<Integer>> verbRuleMap = new HashMap<String, Set<Integer>>();

			Set<Integer> old, temp = null;

			for (RuleStored ruleStored : rulesStored) {

				logger.debug("Checking for verb : " + ruleStored.getProvider_information());

				if ((old = verbRuleMap.get(ruleStored.getProvider_information())) == null) {

					logger.debug("Verb doesn't exist");

					temp = new HashSet<Integer>();

					temp.add(Integer.parseInt(ruleStored.getId()));

					verbRuleMap.put(ruleStored.getProvider_information(), temp);

				} else {

					logger.debug("Verb exists");

					old.add(Integer.parseInt(ruleStored.getId()));

				}

			}

			Set<Integer> rules = null;

			Job job = null;

			newJob.setUser("Workflow Service");

			newJob.setValidationType("OAI Usage");

			newJob.setStatus("working");

			newJob.setJobType("Workflow Request");

//			newJob.setRuleset("Workflow Request");

			//TODO FIX

			newJob.setGuidelines("OpenAIRE For Literature Repositories");

			newJob.setActivation_id(null);

			newJob.setDuration("--");

			newJob.setRepo(pros.getProperty(OAIPMHSinglePageVerbProvider.BASEURL));

			newJob.setRules(ruleIdsUsage);

			newJob.setMetadata_prefix(pros.getProperty(OAIPMHRecordProvider.METADATA_PREFIX));

			newJob.setId("-1");

			int jobIdStored = jobSubmittedDao.save(newJob);

			Map<Integer,Integer> ruleLinkingMap = new HashMap<Integer,Integer>();

			ValidatorJobListener listener = createListener();

			listener.setJobSubmittedId(jobIdStored);

			listener.setJobSubmittedUser("Workflow Service");

			listener.setRuleLinkingMap(ruleLinkingMap);

			listener.setInternalJobsSum(verbRuleMap.size());

			for (Map.Entry<String, Set<Integer>> entry : verbRuleMap.entrySet()) {

				pros.remove(OAIPMHSinglePageVerbProvider.VERB);

				pros.setProperty(OAIPMHSinglePageVerbProvider.VERB,

						entry.getKey());

				rules = new HashSet<Integer>();

				for (Integer ruleId : entry.getValue()) {

					RuleStored tempRule = ruleStoredDao.get(Integer

							.toString(ruleId));

					logger.debug("prepare to add rule to registry with regexp: " + tempRule.getConfiguration().getProperty("regexp") + " and ruleIdregistry: " + ruleIdRegistry);

					validator.addToRegistry(ruleIdRegistry, this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), ruleIdRegistry), MemoryThreadValidator.RegistryType.rules);

					rules.add(ruleIdRegistry);

//					this.linkRules(ruleIdRegistry, ruleId);

					ruleLinkingMap.put(ruleIdRegistry, ruleId);

					ruleIdRegistry++;

				}

				job = new Job(this.jobIdRegistry, 2, rules, pros);

				DnetListener dnetListener = createDnetListener();

				dnetListener.setJob(bJob);

				dnetListener.setBlackboardHandler(blackboardHandler);

				validator.submitJob(job, 1, listener, dnetListener);

				this.jobIdRegistry++;

			}

			return newJob;

		} catch (Exception e) {

			logger.error("Error Submitting usage job(s)", e);

			throw new ValidatorException(e);

		}

	}

	private Serializable getRuleClassInstanceByType(String type,

			Properties pros, int id) throws ValidatorException {

		logger.debug("getting rule object of type " + type);

		String classname = RuleTypes.getClassOfType(type);

		if (classname == null) {

			logger.debug("error getting rule object of type " + type

					+ " classname=null");

			return null;

		} else {

			try {

				Class<?> clazz = Class.forName(classname);

				logger.debug("classname: " + clazz.getName());

				return (Serializable) clazz.getConstructor(

						new Class[] { Properties.class, Integer.TYPE })

						.newInstance(pros, id);

			} catch (ClassNotFoundException e) {

				logger.debug("error getting rule object: " + e);

				return null;

			} catch (NoSuchMethodException e) {

				logger.debug("error getting rule object: " + e);

				return null;

			} catch (InvocationTargetException e) {

				logger.debug("error getting rule object: " + e);

				return null;

			} catch (InstantiationException e) {

				logger.debug("error getting rule object: " + e);

				return null;

			} catch (IllegalAccessException e) {

				logger.debug("error getting rule object: " + e);

				return null;

			}

		}

	}

	private ChainRule<Rule> handleChain(RuleStored tempRule) throws Exception {

		logger.debug("chain rule found");

		List<Rule> rules_chain = new ArrayList<Rule>();

		RuleStored tempRuleChain1=ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_1"));

		if(tempRuleChain1.getType().equals("ChainRule")) {

			ChainRule<Rule> chainRule1 = this.handleChain(tempRuleChain1);

			rules_chain.add(chainRule1);

			ruleIdRegistry++;

		} else {

			rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain1.getType(), tempRuleChain1.getConfiguration(), ruleIdRegistry));

			ruleIdRegistry++;

		}

		RuleStored tempRuleChain2=ruleStoredDao.get(tempRule.getConfiguration().getProperty("rule_2"));

		if(tempRuleChain2.getType().equals("ChainRule")) {

			ChainRule<Rule> chainRule2 = this.handleChain(tempRuleChain2);

			rules_chain.add(chainRule2);

			ruleIdRegistry++;

		} else {

			rules_chain.add((Rule) this.getRuleClassInstanceByType(tempRuleChain2.getType(), tempRuleChain2.getConfiguration(), ruleIdRegistry));

			ruleIdRegistry++;

		}

		Properties chainPros = new Properties();

		chainPros.setProperty(ChainRule.TYPE,tempRule.getConfiguration().getProperty(ChainRule.TYPE));

		ChainRule<Rule> chainRule = new ChainRule<Rule>(chainPros, ruleIdRegistry, rules_chain);

		return chainRule;

	}

//	private void linkRules(int ruleRegistry, int ruleStored) {

//		this.ruleLinkingMap.put(ruleRegistry, ruleStored);

//	}

//

//	private int getRuleFromLink(int ruleRegistry) {

//		return this.ruleLinkingMap.get(ruleRegistry);

//	}

	public Validator getValidator() {

		return validator;

	}

	public void setValidator(Validator validator) {

		this.validator = validator;

	}

	public JobSubmittedDAO getJobSubmittedDao() {

		return jobSubmittedDao;

	}

	public void setJobSubmittedDao(JobSubmittedDAO jobSubmittedDao) {

		this.jobSubmittedDao = jobSubmittedDao;

	}

	public RuleSetDAO getRuleSetDao() {

		return ruleSetDao;

	}

	public void setRuleSetDao(RuleSetDAO ruleSetDao) {

		this.ruleSetDao = ruleSetDao;

	}

	public RuleStoredDAO getRuleStoredDao() {

		return ruleStoredDao;

	}

	public void setRuleStoredDao(RuleStoredDAO ruleStoredDao) {

		this.ruleStoredDao = ruleStoredDao;

	}

//	public Map<Integer, Integer> getRuleLinkingMap() {

//		return ruleLinkingMap;

//	}

//	public void setRuleLinkingMap(Map<Integer, Integer> ruleLinkingMap) {

//		this.ruleLinkingMap = ruleLinkingMap;

//	}

}

package gr.uoa.di.validator.service;

import eu.dnetlib.api.data.MDStoreService;

import eu.dnetlib.domain.EPR;

import gr.uoa.di.driver.enabling.resultset.ResultSetFactory;

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

import gr.uoa.di.validator.data.DataException;

import gr.uoa.di.validator.data.Provider;

import gr.uoa.di.validator.data.ResultSet;

import gr.uoa.di.validator.execution.ValidationObject;

import gr.uoa.di.validator.impls.valobjs.XMLTextValidationObject;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.List;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.xpath.XPath;

import javax.xml.xpath.XPathConstants;

import javax.xml.xpath.XPathExpression;

import javax.xml.xpath.XPathExpressionException;

import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.ls.DOMImplementationLS;

import org.w3c.dom.ls.LSSerializer;

import org.xml.sax.InputSource;

public class DnetProvider extends Provider{

	private static final long serialVersionUID = -4280319954962194170L;

	private static ServiceLocator<MDStoreService> mdStoreServiceServiceLocator;

	private static ResultSetFactory rsFactory = null;

	public static final String DATASOURCE = "DATASOURCE";

	public static final String BATCH_SIZE = "BATCH_SIZE";

	public static final String RECORDS = "RECORDS";

	public static final String MDSTORE_ID = "MDSTORE_ID";

	public static final String FROM = "FROM";

	public static final String BEGIN_RECORD = "BEGIN_RECORD";

	public static final String UNTIL = "UNTIL";

	public static final String RECORD_FILTER = "RECORD_FILTER";

	public static final String WORKER_ID = "WORKER_ID";

	public static final String WORKERS = "WORKERS";

	public DnetProvider(Integer id) {

		super(id);

	}

	@Override

	public ResultSet<ValidationObject> getValidationObjects() throws ProviderException {

		return new DnetRecordResultSet();

	}

	@Override

	public ResultSet<String> getValidationObjectIds() throws ProviderException,

			UnsupportedOperationException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public ValidationObject getValidationObject(String valObjId)

			throws ProviderException, UnsupportedOperationException {

		// TODO Auto-generated method stub

		return null;

	}

	public static void printXmlDocument(Document document) {

	    DOMImplementationLS domImplementationLS = 

	        (DOMImplementationLS) document.getImplementation();

	    LSSerializer lsSerializer = 

	        domImplementationLS.createLSSerializer();

	    String string = lsSerializer.writeToString(document);

	    System.out.println(string);

	}

	private class DnetResultSet {

		gr.uoa.di.driver.enabling.resultset.ResultSet<String> rs = null;

		protected DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

		protected DocumentBuilder builder;

		protected XPathFactory xfactory = XPathFactory.newInstance();

		protected List<Node> records = null;

		protected int records_sum = 0;

		protected int index = -1;

		protected int pointer = 0;

		protected int recordsNum = 0;

		protected int workers = 0;

		protected int workerId = 0;

		protected int beginRecord = 0;

		protected int endRecord = 0;

		protected String error = null;

		public DnetResultSet() {

			try {

				builder = factory.newDocumentBuilder();

				log.debug("Retrieving the datasource..");

				log.debug("RECORDS " + pros.getProperty(RECORDS));

				log.debug("MDSTORE_ID " + pros.getProperty(MDSTORE_ID));

				log.debug("DATASOURCE: " + pros.getProperty(DATASOURCE));

				log.debug("WORKER_ID: " + pros.getProperty(WORKER_ID));

				workerId = Integer.parseInt(pros.getProperty(WORKER_ID));

				workers = Integer.parseInt(pros.getProperty(WORKERS));

//				log.debug("BEGIN RECORD: " + pros.getProperty(BEGIN_RECORD));

//				EPR epr = mdStoreServiceServiceLocator.getService().deliverMDRecords(pros.getProperty(MD_ID), pros.getProperty(FROM), pros.getProperty(UNTIL), pros.getProperty(RECORD_FILTER));

				log.debug("Issuing request on mdstore: " + pros.getProperty(MDSTORE_ID));

				EPR epr = mdStoreServiceServiceLocator.getService().deliverMDRecords(pros.getProperty(MDSTORE_ID), null, null, null);

				rs = rsFactory.createResultSet(epr);

				log.debug("rs created");

				records_sum = rs.size();

				log.debug("Number of records in ResultSet: " + records_sum);

				if (pros.getProperty(RECORDS).equalsIgnoreCase("all") ) {

					pros.setProperty(RECORDS,Integer.toString(records_sum));

				} else if (Integer.parseInt(pros.getProperty(RECORDS)) > records_sum) {

					pros.setProperty(RECORDS,Integer.toString(records_sum));

				}

				recordsNum = Integer.parseInt(pros.getProperty(RECORDS));

				log.error("W"+ workerId + "# RECORDS TO TEST: " + recordsNum);

				log.error("W"+ workerId + "# WORKERS: " + workers);

//				pros.setProperty(DnetProvider.BEGIN_RECORD, Integer.toString(Integer.parseInt(pros.getProperty(WORKER_ID)) * (Integer.parseInt(pros.getProperty(RECORDS))/Integer.parseInt(pros.getProperty(WORKERS)))));

				beginRecord = workerId * (recordsNum/workers);

				endRecord = (recordsNum/workers) + beginRecord;

//				endRecord = Integer.parseInt(pros.getProperty(RECORDS))/Integer.parseInt(pros.getProperty(WORKERS)) + Integer.parseInt(pros.getProperty(BEGIN_RECORD));

				if (workerId == workers-1)

					endRecord += recordsNum % workers;

				log.error("W"+ workerId + "# BEGIN RECORD: " + beginRecord);

				log.error("W"+ workerId + "# END RECORD: " + endRecord);

				pointer = beginRecord;

			} catch (ParserConfigurationException e) {

				log.error("", e);

			} catch (Exception e) {

				log.error("", e);

			}

		}

		protected List<Node> getRecords() throws DataException {

			List<Node> records = new ArrayList<Node>();

			try {

				int to = pointer + Integer.parseInt(pros.getProperty(BATCH_SIZE)) -1 ;

				log.error("to : " + to + " and limit: " + endRecord); 

				if (to < endRecord) {

					log.error("Issuing request for records. From : " + pointer + " to : " + to); 

					List<String> tempRecords = rs.get(pointer, to);

					pointer += Integer.parseInt(pros.getProperty(BATCH_SIZE));

					for (String record : tempRecords) {

	//					log.debug("record from resultSet is : " + record);

						InputSource is = new InputSource(new StringReader(record));

						Document doc = builder.parse(is);

						XPath xpath = xfactory.newXPath();

						XPathExpression expr = xpath.compile("//*[local-name()='record']");

						records.add((Node) expr.evaluate(doc, XPathConstants.NODE));

					}

				}

				if (records.size() == 0) {

					log.debug("There are no records. ");

					error = "There are no records";

					log.debug("Error: "+ error);

				}

			} catch (Exception e) {

				log.error("", e);

				throw new DataException();

			}

			return records;

		}		

	}

	private class DnetRecordResultSet extends DnetResultSet implements ResultSet<ValidationObject> {

		@Override

		public String getError() {

			if (error != null)

				log.debug("An error occured "+ this.error);

			else

				log.debug("No errors on request");

			return this.error;

		}

		@Override

		public boolean next() throws DataException {

			index++;

			log.debug("Moving cursor to result "+index);

			if (records == null || index >= records.size()) {

				if (records != null && (records.size() == 0))

					return false;

				index = -1;

				records = getRecords();

				return next();

			}

			return true;

		}

		@Override

		public ValidationObject get() throws DataException {

			XMLTextValidationObject ret = null;

			Document newXmlDocument;

			try {

				newXmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();

		        Element root = newXmlDocument.createElement("root");

		        newXmlDocument.appendChild(root);

	            Node node = records.get(index);

	            Node copyNode = newXmlDocument.importNode(node, true);

	            root.appendChild(copyNode);

	            printXmlDocument(newXmlDocument);

	            ret = new XMLTextValidationObject(newXmlDocument);

	            XPathFactory factory = XPathFactory.newInstance();

	            XPath xPath = factory.newXPath();

	            ret.setId(xPath.evaluate("//*[local-name()='header']/*[name()='dri:recordIdentifier']/text()", records.get(index)));

	            ret.setStatus(xPath.evaluate("//*[local-name()='header']/@status", records.get(index)));

	            log.debug("record id: " + ret.getId());

	            log.debug("record status: " + ret.getStatus());

			} catch (ParserConfigurationException e) {

				log.error("error getting object"+ e);

			} catch (XPathExpressionException e) {

				log.error("error getting object"+ e);

			}			

			return ret;

		}

	}

	public static ResultSetFactory getRsFactory() {

		return rsFactory;

	}

	public static void setRsFactory(ResultSetFactory rsFactory) {

		DnetProvider.rsFactory = rsFactory;

	}

	public static ServiceLocator<MDStoreService> getMdStoreServiceServiceLocator() {

		return mdStoreServiceServiceLocator;

	}

	public static void setMdStoreServiceServiceLocator(ServiceLocator<MDStoreService> mdStoreServiceServiceLocator) {

		DnetProvider.mdStoreServiceServiceLocator = mdStoreServiceServiceLocator;

	}

}

package gr.uoa.di.validator.service;

import eu.dnetlib.api.functionality.ValidatorService;

import eu.dnetlib.domain.ActionType;

import eu.dnetlib.domain.EPR;

import eu.dnetlib.domain.ResourceType;

import eu.dnetlib.domain.enabling.Notification;

import eu.dnetlib.enabling.tools.blackboard.BlackboardNotificationHandler;

import eu.dnetlib.enabling.tools.blackboard.BlackboardServerHandler;

import gr.uoa.di.driver.app.DriverServiceImpl;

import gr.uoa.di.driver.enabling.issn.NotificationListener;

import org.apache.log4j.Logger;

public class ValidatorServiceImpl extends DriverServiceImpl implements

		ValidatorService {

	private BlackboardNotificationHandler<BlackboardServerHandler> blackboardNotificationHandler = null;

	private Logger logger = Logger.getLogger(ValidatorServiceImpl.class);

	// do NOT call directly. It will be called by the

	// InitializingServiceRegistrationManager

	// after it sets the service EPR and id.

	@Override

	public void init() {

		super.init();

		this.subscribe(ActionType.UPDATE,

				ResourceType.VALIDATORSERVICERESOURCETYPE, this

						.getServiceEPR().getParameter("serviceId"),

				"RESOURCE_PROFILE/BODY/BLACKBOARD/LAST_REQUEST",

				new NotificationListener() {

					@Override

					public void processNotification(Notification notification) {

						blackboardNotificationHandler.notified(

								notification.getSubscriptionId(),

								notification.getTopic(),

								notification.getIsId(),