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.0</version>

	<scm>

		<developerConnection>scm:svn:https://svn.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-validator/tags/uoa-validator-1.0.0</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>

package gr.uoa.di.validator.impls.rules.text;

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

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

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

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

import java.util.Properties;

/**

 * Checks if the {@link TextValidationObject} containes a value contained in the {@link VocabularyRule#TERMS}.

 * @author Manos Karvounis

 *

 */

public class TextVocabularyRule extends VocabularyRule implements TextRule {

	private static final long serialVersionUID = 7959834222669049476L;

	public TextVocabularyRule(Properties pros, int id) {

		super(pros, id);

	}

	@Override

	public boolean apply(ValidationObject obj) throws RuleException {

		TextValidationObject tobj = (TextValidationObject) obj;

		String[] aterms = this.pros.getProperty(TERMS).split(",");

		for(String term : aterms)

			if(term.trim().equals(tobj.getContentAsText()))

				return true;

		return false;

	}

}

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.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.impls.rules;

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

import java.util.Properties;

/**

 * Represents a rule that checks if an object has a value matching the Regular Expression {@link RegularExpressionRule#REGEXP}

 * @author Manos Karvounis

 *

 */

public abstract class RegularExpressionRule extends Rule {

	public static final String REGEXP = "regexp";

	private static final long serialVersionUID = 2159775453207438509L;

	public RegularExpressionRule(Properties pros, int id) {

		super(pros, id);

	}

}

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 org.apache.log4j.Logger;

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;

public class NotificationListener extends

		BlackboardNotificationHandler<BlackboardServerHandler> {

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

	private ValidatorManager valManager;

	@Override

	protected void processJob(BlackboardJob job) {

		super.processJob(job);

		logger.debug("New Job!");

		String baseUrl = job.getParameters().get("baseUrl");

		String validationSet = job.getParameters().get("validationSet");

		String validationType = job.getParameters().get("validationType");

		String type = job.getParameters().get("type"); //OAI

		String mdstoreId = job.getParameters().get("mdstoreId");

		String guidelines = job.getParameters().get("guidelines");

		String groupBy = job.getParameters().get("groupBy");

//		String workers = job.getParameters().get("workers");

		String workers = "4";

		logger.debug("New Job of type: " + type);

		try {

			if (type.equalsIgnoreCase("OAI")) {

				logger.debug("type is oai");

//				if (validationType.equalsIgnoreCase("OAI Content Validation"))

//					valManager.beginContentJobForWorkflow(baseUrl, validationSet, job, this);

//				else if (validationType.equalsIgnoreCase("OAI Usage Validation"))

//					valManager.beginUsageJobForWorkflow(baseUrl, validationSet, job, this);

//				else

//					throw new ValidatorException("Unknown validation type " + type);

			} else if (type.equalsIgnoreCase("DNET")) {

				logger.debug("type is dnet");

				logger.debug("groupBy: " + groupBy);

				valManager.beginDataJobForWorkflow(mdstoreId, guidelines, groupBy, job, this,Integer.parseInt(workers));

			}

			this.getBlackboardHandler().ongoing(job);

		} catch (ValidatorException e) {

			logger.error("Failed to begin the workflow for the job received", e);

			getBlackboardHandler().failed(job, e);

		}

//		valManager.preRegistrationValidations(baseUrl, officialName, activationId, userMail, adminMail, validationSet, datasourceId)

		//TODO: kaleitai otan erxetai notification apo to DNET gia 

		// ksekinisei douleia. Pairneis parametrous apo to job

		// antikeimeno:

		// job.getParameters().get("a param name ");

		// kai kapws kaleis to validator engine.

		// kai enimerwneis gia to status tou job:

	}

	public ValidatorManager getValManager() {

		return valManager;

	}

	public void setValManager(ValidatorManager valManager) {

		this.valManager = valManager;

	}

}

package gr.uoa.di.validator.impls.persistance;

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

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

import gr.uoa.di.validator.persistance.Persistance;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import java.util.UUID;

import org.apache.log4j.Logger;

import com.thoughtworks.xstream.XStream;

/**

 * A Persistance mechanism that stores the objects as XML files.

 * A path needs to be provided that points to the directory where the files will be stored.

 * @author Manos Karvounis

 * @see XMLFilePersistance#DIRECTORY

 */

public class XMLFilePersistance implements Persistance {

	private XStream xstream = null;

	private Properties props = null;

	private String versionForRestore = null;

	private String versionForPersist = null;

	private Map<String, Integer> nums = new HashMap<String, Integer>();

	private transient Logger log = Logger.getLogger(XMLFilePersistance.class);

	/**

	 * A path that points to the directory where the files will be stored.

	 * The path must exist already.

	 */

	public final static String DIRECTORY = "directory";

	public XMLFilePersistance(Properties props) {

		super();

		this.props = props;

	}

	@Override

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

		if (this.versionForPersist == null)

			try {

				getNextVersion();

				log.debug("Persisting to version "+this.versionForPersist);

			} catch (IOException e1) {

				log.error("", e1);

				throw new DataException();

			}

		if (nums.get(container) == null)

			nums.put(container, 0);

		int num = nums.get(container);

		nums.put(container, num + 1);

		FileOutputStream stream = null;

		try {

			log.debug("Writing object "+objid+" to disk");

			stream = new FileOutputStream(new File(getFileName(container, num, true)));

			xstream.toXML(obj, stream);

			stream.close();

		} catch (FileNotFoundException e) {

			log.error("", e);

			throw new DataException();

		} catch (IOException e) {

			log.error("", e);

			throw new DataException();

		} finally {

			if (stream != null)

				try {

					stream.close();

				} catch (IOException e) {

					log.error("FATAL IO ERROR", e);

				}

		}

	}

	@Override

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

		if (this.versionForRestore == null)

			try {

				getLatestVersion();

				log.debug("Restore version "+this.versionForRestore);

			} catch (IOException e1) {

				log.error("", e1);

				throw new DataException();

			}

		return new XMLFilesResultSet<T>(container);

	}

	private String getFileName(String container, int num, boolean persist) {

		String version;

		if (persist)

			version = this.versionForPersist;

		else

			version = this.versionForRestore;

		return props.getProperty(DIRECTORY) + "/" + version + "/" + container + "." + num + ".xml";

	}

	private String getNextVersion() throws IOException {

		log.debug("creating new persistance file on directory: "+props.getProperty(DIRECTORY));

		File version = new File(props.getProperty(DIRECTORY) + "/version");

		if (!version.exists()) {

			version.createNewFile();

			this.versionForPersist = "0";

		}

		BufferedWriter bw = new BufferedWriter(new FileWriter(version));

		this.versionForPersist = UUID.randomUUID().toString();

		bw.write(this.versionForPersist);

		bw.close();

		File versionDirectory = new File(props.getProperty(DIRECTORY) + "/" + this.versionForPersist + "/");

		versionDirectory.mkdir();

		return this.versionForPersist;

	}

	private String getLatestVersion() throws IOException {

		File file = new File(props.getProperty(DIRECTORY) + "/version");

		if (!file.exists())

			this.versionForRestore = "0";

		else {

			BufferedReader br = new BufferedReader(new FileReader(file));

			this.versionForRestore = br.readLine();

			br.close();

		}

		return this.versionForRestore;

	}

	@Override

	public void open() throws DataException {

		xstream = new XStream();

		try {

			getLatestVersion();

		} catch (IOException e) {

			log.error("", e);

			throw new DataException();

		}

		// if it is the first time we created a validator

		if(this.versionForRestore.equals("0")) {

			File versionDirectory = new File(props.getProperty(DIRECTORY) + "/" + this.versionForRestore + "/");

			versionDirectory.mkdir();

		}

	}

	@Override

	public void close() {

		xstream = null;

		File dir = new File(props.getProperty(DIRECTORY));

		if(dir.exists() && dir.isDirectory()) {

			String[] dirNames = dir.list();

			for(String dirName : dirNames)

				if(!dirName.equals(this.versionForPersist) && !dirName.equals(this.versionForRestore) && !dirName.equals("version")) {

					log.debug("Deleting older version "+dirName);

					deleteDir(new File(props.getProperty(DIRECTORY) + "/" + dirName + "/"));

				}

		}

	}

	private boolean deleteDir(File dir) {

		if (dir.exists() && dir.isDirectory()) {

			String[] children = dir.list();

			for (int i = 0; i < children.length; i++) {

				boolean success = deleteDir(new File(dir, children[i]));

				if (!success) {

					return false;

				}

			}

		}

		return dir.delete();

	}

	public class XMLFilesResultSet<T extends Serializable> implements ResultSet<T> {

		private final String container;

		private T current = null;

		private int num = 0;

		public XMLFilesResultSet(String container) {

			super();

			this.container = container;

		}

		@SuppressWarnings("unchecked")

		@Override

		public boolean next() throws DataException {

			log.debug("Moving cursor to object from container "+container+" with num "+num);

			File file = new File(getFileName(container, num++, false));

			if (file.exists()) {

				current = (T) xstream.fromXML(file);

				return true;

			} else {

				current = null;

				return false;

			}

		}

		@Override

		public T get() throws DataException {

			return current;

		}

		@Override

		public String getError() {

			// TODO Auto-generated method stub

			return null;

		}

	}

}

package gr.uoa.di.validator.service;

public class resultsetCReator {

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

//		EPR epr = new EPR();

//		epr.setAddress("http://node1.t.openaire.research-infrastructures.eu:8980/dnet/services/resultSet");

//		epr.setParameter("ResourceIdentifier", "rs-e6a11c26-1a16-41c8-a123-288e75bcbf7b");

//

//		System.out.println("dnet://EPR/" + URIUtil.encodePath(EPRUtils.createW3CEPR(epr).toString()));

//	}

}

package gr.uoa.di.validator.impls.rules.xml;

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

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

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

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

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

import java.util.Properties;

import org.w3c.dom.NodeList;

public class XMLCardinalityRule extends CardinalityRule implements XMLRule {

	private static final long serialVersionUID = -3293960407395273309L;

	public XMLCardinalityRule(Properties pros, int id) {

		super(pros, id);

	}

	@Override

	public boolean apply(ValidationObject obj) throws RuleException {

		XMLTextValidationObject tobj = (XMLTextValidationObject) obj;

		NodeList nodes;

		try {

			nodes = tobj.getNodes(this.pros.getProperty(XPATH));

		} catch (DataException e) {

			log.error("", e);

			return false;

		}

		int number = nodes.getLength();

		log.debug("XML Cardinality Rule. Count: "+number);

		if (number < Integer.parseInt(pros.getProperty(LESS_THAN)) && number > Integer.parseInt(pros.getProperty(GREATER_THAN)))

			return true;

		else

			return false;

	}

}

package gr.uoa.di.validator.impls.valobjs;

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

import java.io.StringWriter;

import javax.xml.transform.Result;

import javax.xml.transform.Source;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.TransformerFactoryConfigurationError;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

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.apache.log4j.Logger;

import org.w3c.dom.Document;

import org.w3c.dom.NodeList;

/**

 * Indicates that a Validation Object is actually an xml text.

 * @author Manos Karvounis

 */

public class XMLTextValidationObject implements TextValidationObject {

	private transient Logger log = Logger.getLogger(XMLTextValidationObject.class);

	private String id = "";

	private String status;

	private final Document doc;

	private XPathFactory factory = XPathFactory.newInstance();

	public XMLTextValidationObject(Document doc) {

		super();

		this.doc = doc;

	}

	@Override

	public String getId() {

		return this.id;

	}

	@Override

	public void setId(String id) {

		this.id = id;

	}

	public String getStatus() {

		return status;

	}

	public void setStatus(String status) {

		this.status = status;

	}

	@Override

	public Object getContentAsObject() {

		return this.doc;

	}

	@Override

	public String getContentAsText() {

		StringWriter sw = new StringWriter();

	    Transformer transformer = null;

		try {