D-Net

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

	<display-name>Validator Web Service</display-name>

package gr.uoa.di.validator.service.impl;

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

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

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

import eu.dnetlib.validator.service.dao.jobs.JobSubmitted;

import gr.uoa.di.validator.ValidatorException;

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.impl;

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

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

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

import eu.dnetlib.validator.service.dao.Utilities;

import eu.dnetlib.validator.service.dao.jobs.JobSubmitted;

import eu.dnetlib.validator.service.dao.jobs.JobSubmittedDAO;

import eu.dnetlib.validator.service.dao.rules.RuleSet;

import eu.dnetlib.validator.service.dao.rules.RuleSetDAO;

import eu.dnetlib.validator.service.dao.rules.RuleStored;

import eu.dnetlib.validator.service.dao.rules.RuleStoredDAO;

import gr.uoa.di.validator.Validator;

import gr.uoa.di.validator.ValidatorException;

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.DnetProvider;

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 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.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, workers, listener, dnetListener);

			return newJob;

		} catch (Exception e) {

			logger.error("Error Submitting content job", 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");

			//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.impl;

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(),

								notification.getMessage());

						logger.debug(notification.getSubscriptionId());

						logger.debug(notification.getTopic());

						logger.debug(notification.getIsId());

						logger.debug(notification.getMessage());

					}

				});

	}

	public BlackboardNotificationHandler<BlackboardServerHandler> getBlackboardNotificationHandler() {

		return blackboardNotificationHandler;

	}

	public void setBlackboardNotificationHandler(

			BlackboardNotificationHandler<BlackboardServerHandler> blackboardNotificationHandler) {

		this.blackboardNotificationHandler = blackboardNotificationHandler;

	}

	@Override

	public EPR validate(EPR datasource) {

		throw new UnsupportedOperationException();

	}

}

package gr.uoa.di.validator.service.impl;

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 eu.dnetlib.validator.service.dao.jobs;

import java.util.List;

public class Entry {

	private String name, description;

	private String successes;

	private int weight;

	private List<String> errors;

	private int ruleId;

	private boolean hasErrors, mandatory;

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getSuccesses() {

		return successes;

	}

	public void setSuccesses(String successes) {

		this.successes = successes;

	}

	public List<String> getErrors() {

		return errors;

	}

	public void setErrors(List<String> errors) {

		this.errors = errors;

	}

	public void setRuleId(int ruleId) {

		this.ruleId = ruleId;

	}

	public int getRuleId() {

		return ruleId;

	}

	public void setHasErrors(boolean hasErrors) {

		this.hasErrors = hasErrors;

	}

	public boolean isHasErrors() {

		return hasErrors;

	}

	public void setWeight(int weight) {

		this.weight = weight;

	}

	public int getWeight() {

		return weight;

	}

	public boolean isMandatory() {

		return mandatory;

	}

	public void setMandatory(boolean mandatory) {

		this.mandatory = mandatory;

	}

}

package eu.dnetlib.validator.service.dao.jobs;

import java.util.Set;

public class JobSubmitted {

	private String status, started, ended, score, id, user, repo, duration, error , records, set, groupBy_xpath, metadata_prefix, activation_id;

	private String validationType, jobType, guidelines;

	private Set<Integer> rules;

	public String getDuration() {

		return duration;

	}

	public void setDuration(String duration) {

		this.duration = duration;

	}

	public String getRepo() {

		return repo;

	}

	public void setRepo(String repo) {

		this.repo = repo;

	}

	public String getUser() {

		return user;

	}

	public void setUser(String user) {

		this.user = user;

	}

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public String getStatus() {

		return status;

	}

	public void setStatus(String status) {

		this.status = status;

	}

	public String getStarted() {

		return started;

	}

	public void setStarted(String started) {

		this.started = started;

	}

	public String getEnded() {

		return ended;

	}

	public void setEnded(String ended) {

		this.ended = ended;

	}

	public String getScore() {

		return score;

	}

	public void setScore(String score) {

		this.score = score;

	}

	public String getError() {

		return error;

	}

	public void setError(String error) {

		this.error = error;

	}

	public Set<Integer> getRules() {

		return rules;

	}

	public void setRules(Set<Integer> rules) {

		this.rules = rules;

	}

	public String getRecords() {

		return records;

	}

	public void setRecords(String records) {

		this.records = records;

	}

	public String getSet() {

		return set;

	}

	public void setSet(String set) {

		this.set = set;

	}

	public String getGroupBy_xpath() {

		return groupBy_xpath;

	}

	public void setGroupBy_xpath(String groupBy_xpath) {

		this.groupBy_xpath = groupBy_xpath;

	}

	public String getMetadata_prefix() {

		return metadata_prefix;

	}

	public void setMetadata_prefix(String metadata_prefix) {

		this.metadata_prefix = metadata_prefix;

	}

	public String getActivation_id() {

		return activation_id;

	}

	public void setActivation_id(String activation_id) {

		this.activation_id = activation_id;

	}

	public String getGuidelines() {

		return guidelines;

	}

	public void setGuidelines(String guidelines) {

		this.guidelines = guidelines;

	}

	public String getValidationType() {

		return validationType;

	}

	public void setValidationType(String validationType) {

		this.validationType = validationType;

	}

	public String getJobType() {

		return jobType;

	}

	public void setJobType(String jobType) {

		this.jobType = jobType;

	}

}

package eu.dnetlib.validator.service.email;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

public class BugReporter {

	private transient Logger logger = Logger.getLogger(BugReporter.class);

	private String ex = null;

	public void report() {

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

		try {

			recipients.add("nikonas@di.uoa.gr");

			String message = "An exception has occurred:\n"+ex;

			String subject = "Automatic Bug Report";

//			this.getEmailer().sendMail(recipients, subject, message, false, null);

		} catch (Exception e) {

			logger.error("error sending error report", e);

		}

	}

	public void setEx(String ex) {

		this.ex = ex;

	}

	public String getEx() {

		return ex;

	}

}

<?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>

package eu.dnetlib.validator.service.dao.users;

public class UserStored {

	private String email;

	private String password;

	private String activationId;

	public String getEmail() {

		return email;

	}

	public void setEmail(String email) {

		this.email = email;

	}

	public String getPassword() {

		return password;

	}

	public void setPassword(String password) {

		this.password = password;

	}

	public String getActivationId() {

		return activationId;

	}

	public void setActivationId(String activationId) {

		this.activationId = activationId;

	}

}

<?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.jobs.JobSubmittedDAOImpl">

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

	</bean>

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

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

	</bean>

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

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

	</bean>	

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

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

	</bean>		

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

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

	</bean>		

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

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

	</bean>				

</beans>

log4j.appender.R.File = /tmp/log/validator-service.log

log4j.appender.S.File = /tmp/log/validator-service-spring.log

package eu.dnetlib.validator.service.dao.users;

import eu.dnetlib.validator.service.dao.DAO;

public interface UserStoredDAO extends DAO<UserStored> {

	public boolean checkCorrectCreds(UserStored newUser);

	public boolean isAdmin(String email);

	public boolean isRepoAdmin(String email);

	public boolean isActivated(String email);

	public boolean userExists(String email);

	public void prepareResetPassword(String uuid, String email);

	public void ResetPassword(String uuid, String password);

}

package eu.dnetlib.validator.service.dao.users;

import eu.dnetlib.validator.service.dao.AbstractDAO;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class UserStoredDAOimpl extends AbstractDAO<UserStored> implements UserStoredDAO {

	@Override

	protected PreparedStatement getUpdateStatement(UserStored t, Connection con)

			throws SQLException {

		String query="UPDATE users SET activation_id=? WHERE activation_id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, null);

		stmt.setString(2, t.getActivationId());

		return stmt;

	}

	@Override

	protected PreparedStatement getInsertStatement(UserStored t, Connection con)

			throws SQLException {

		String query="INSERT INTO users(email,password,activation_id) VALUES(?,?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, t.getEmail());

		stmt.setString(2, t.getPassword());

		stmt.setString(3, t.getActivationId());		

		return stmt;

	}

	@Override

	protected PreparedStatement getDeleteStatement(String id, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	protected int getLastId() throws SQLException {

		// TODO Auto-generated method stub

		return 0;

	}

	@Override

	public UserStored get(String id) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public boolean checkCorrectCreds(UserStored newUser) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check correct credentials");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=? AND password=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,newUser.getEmail());

			stmt.setString(2,newUser.getPassword());

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to check correct credentials: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check correct credentials: "+e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isAdmin(String email) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is admin");

		try {

			con = getConnection();

			String query="SELECT * FROM admins WHERE username=? AND level=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			stmt.setString(2,"secondary");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to check if user is admin: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is admin: "+e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isRepoAdmin(String email) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is repoAdmin");

		try {

			con = getConnection();

			String query="SELECT * FROM admins WHERE username=? AND level=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			stmt.setString(2,"secondary");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to check if user is repoAdmin: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is repoAdmin: "+e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isActivated(String email) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is activated");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=? AND activation_id is null";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

//			stmt.setString(2,"NULL");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to check if user is activated "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is activated "+e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean userExists(String email) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user "+email+" exists");

		try {

			con = getConnection();

//			con.setAutoCommit(false); 

//			con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

			String query="SELECT * FROM users WHERE email=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			rs = stmt.executeQuery();

			if (rs.next()){

				logger.debug("user exists");

				return true;

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to check if user exists: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user exists: "+e);

				}

			}

		}

		return false;

	}

	@Override

	public void prepareResetPassword(String uuid, String email) {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to prepare reset password");

		try {

			con = getConnection();

			String query="UPDATE users SET activation_id=? WHERE email=?";;

			stmt = con.prepareStatement(query);

			stmt.setString(1,uuid);

			stmt.setString(2,email);

			stmt.executeUpdate();

		} catch (SQLException e) {

			logger.error("Error while accessing DB to prepare reset password: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to prepare reset password: "+e);

				}

			}

		}

	}

	@Override

	public void ResetPassword(String uuid, String password) {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to reset password");

		try {

			con = getConnection();

			String query="UPDATE users SET password=? WHERE activation_id=?";;

			stmt = con.prepareStatement(query);

			stmt.setString(1,password);

			stmt.setString(2,uuid);

			stmt.executeUpdate();

		} catch (SQLException e) {

			logger.error("Error while accessing DB to reset password: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to reset password: "+e);

				}

			}

		}

	}

}

package eu.dnetlib.validator.service.dao;

public interface DAO<T> {

	public Integer save (T t);

//	public String delete (T t);

	public String delete (String id);

	public T get (String id);

}

package eu.dnetlib.validator.service.dao.tasks;

public class TaskStored {

	private String status, started, ended, jobId, ruleId, valObjId, recordIdentifier, recordUrl;

	private boolean success;

//	private RuleD rule;

	public String getRecordUrl() {

		return recordUrl;

	}

	public void setRecordUrl(String recordUrl) {

		this.recordUrl = recordUrl;

	}

	public String getStatus() { 

		return status;

	}

	public void setStatus(String status) {

		this.status = status;

	}

	public boolean getSuccess() {

		return success;

	}

	public void setSuccess(boolean success) {

		this.success = success;

	}

	public String getStarted() {

		return started;

	}

	public void setStarted(String started) {

		this.started = started;

	}

	public String getEnded() {

		return ended;

	}

	public void setEnded(String ended) {

		this.ended = ended;

	}

	public String getJobId() {

		return jobId;

	}

	public void setJobId(String jobId) {

		this.jobId = jobId;

	}

	public String getRuleId() {

		return ruleId;

	}

	public void setRuleId(String ruleId) {

		this.ruleId = ruleId;

	}

	public String getValObjId() {

		return valObjId;

	}

	public void setValObjId(String valObjId) {

		this.valObjId = valObjId;

	}

	public String getRecordIdentifier() {

		return recordIdentifier;

	}

	public void setRecordIdentifier(String recordIdentifier) {

		this.recordIdentifier = recordIdentifier;

	}

//	public RuleD getRule() {

//		return rule;

//	}