D-Net

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

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import eu.dnetlib.utils.MailLibrary;

public class Emailer {

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

	private List<String> specialRecipients = new ArrayList<String>();

	private boolean override = false, logonly = false;

	private String overrideEmail = null, from = null;

	private MailLibrary mailer = null;

	public void sendMail(List<String> recipients, String subject, String message, boolean sendToSpecial, List<String> repoAdminMails) throws Exception {

		try {

			if (sendToSpecial) {

				recipients.addAll(this.specialRecipients);

			}

			if (repoAdminMails != null)

				recipients.addAll(repoAdminMails);

			if (this.override) {

				recipients.clear();

				recipients.add(overrideEmail);

			}

			logger.debug("Sending mail to Recipients: " + recipients + " Subject: " + subject + " Message: " + message);

			if (!logonly)

				mailer.sendEmail(recipients.toArray(new String[] {}), subject, message);

		} catch (Exception e) {

			logger.error("Error sending mail to Recipients: " + recipients + " Subject: " + subject + " Message: " + message, e);

			throw new Exception(e);

		}

	}

	public void setSpecialRecipients(String specialRecipients) {

		String[] recps = specialRecipients.split(",");

		for (String recp : recps) {

			recp = recp.trim();

			this.specialRecipients.add(recp);

		}

	}

	public void setOverride(boolean override) {

		this.override = override;

	}

	public void setOverrideEmail(String overrideEmail) {

		this.overrideEmail = overrideEmail;

	}

	public void setMailer(MailLibrary mailer) {

		this.mailer = mailer;

	}

	public String getFrom() {

		return from;

	}

	public void setFrom(String from) {

		this.from = from;

	}

	public boolean isLogonly() {

		return logonly;

	}

	public void setLogonly(boolean logonly) {

		this.logonly = logonly;

	}

}

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;

	}

}

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;

//	}

//	public void setRule(RuleD rule) {

//		this.rule = rule;

//	}

}

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

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

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

import java.util.List;

import java.util.Map;

public interface TaskStoredDAO extends DAO<TaskStored> {

	public List<TaskStored> getTasksOfJob(String id);

	public List<String> getValidationErrors(String jobId, String ruleId);

	public List<String> getDistinctTasksOfJob(String jobId);

	public List<TaskStored> getFinishedTasks(String jobId, String ruleId);

	public void saveTasks(List<TaskStored> tasksStored, List<String> sets);

	public void cleanTasks(int jobId);

	public void saveTasksBatch(List<TaskStored> tasks, Map<String, List<String>> groupByMap);

	public void saveTasks(Map<String, RuleStatus> scoreMapPerRule);

}

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

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

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

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

public class TaskStoredDAOimpl extends AbstractDAO<TaskStored> implements TaskStoredDAO{

	@Override

	protected PreparedStatement getUpdateStatement(TaskStored t, Connection con)

			throws SQLException {

		String query="UPDATE tasks set status=?, success=?, started=?, ended=?, record_url=? WHERE job_id=? AND rule_id=? AND record_identifier=?";

		PreparedStatement stmt = con.prepareStatement(query);

//		logger.debug("getting taskStored updateStatement");

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

		stmt.setBoolean(2, t.getSuccess());

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

		stmt.setString(4, t.getEnded());

		stmt.setString(5, t.getRecordUrl());	

		stmt.setInt(6, Integer.parseInt(t.getJobId()));

		stmt.setInt(7, Integer.parseInt(t.getRuleId()));

		stmt.setString(8, t.getRecordIdentifier());

		return stmt;

	}

	@Override

	protected PreparedStatement getInsertStatement(TaskStored t, Connection con) throws SQLException {

		String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

//		logger.debug("getting taskStored insertStatement");

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

		stmt.setBoolean(2, t.getSuccess());

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

		stmt.setString(4, t.getEnded());

		stmt.setInt(5, Integer.parseInt(t.getJobId()));

		stmt.setInt(6, Integer.parseInt(t.getRuleId()));

		stmt.setString(7, t.getRecordIdentifier());

		stmt.setString(8, t.getRecordUrl());		

		return stmt;

	}

	@Override

	protected PreparedStatement getDeleteStatement(String id, Connection con)

			throws SQLException {

		String query="DELETE FROM tasks WHERE job_id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setInt(1, Integer.parseInt(id));

		return stmt;

	}

	@Override

	public List<TaskStored> getTasksOfJob(String id) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		TaskStored retTask = null;

		List<TaskStored> retList = null; 

		logger.debug("Accessing DB to get all Tasks of Job");

		try {

			con = getConnection();

			String query="SELECT status, success, started, ended, rule_id, record_identifier, record_url FROM tasks WHERE job_id=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1, id);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<TaskStored>();

				while (rs.next()) {

					retTask = new TaskStored();

					retTask.setStatus(rs.getString(1));

					retTask.setSuccess(rs.getBoolean(2));

					retTask.setStarted(rs.getString(3));

					retTask.setEnded(rs.getString(4));

					retTask.setRuleId(Integer.toString(rs.getInt(5)));

					retTask.setRecordIdentifier(rs.getString(6));

					retTask.setRecordUrl(rs.getString(7));

					retTask.setJobId(id);

					retList.add(retTask);

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get all Tasks of Job: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get all Tasks of Job: "+e);

				}

			}

		}

		return retList;

	}

	@Override

	public TaskStored get(String id) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public List<String> getValidationErrors(String jobId, String ruleId) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<String> retList = null; 

		logger.debug("Accessing DB to get Validation Errors of JobId " + jobId + " and RuleId " + ruleId);

		try {

			con = getConnection();

			String query="SELECT record_identifier FROM tasks WHERE job_id=? AND rule_id=? AND success=? LIMIT 30";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, Integer.parseInt(jobId));

			stmt.setInt(2, Integer.parseInt(ruleId));

			stmt.setBoolean(3, false);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();

				while (rs.next()) {

//					if (!rs.getBoolean(1))

					retList.add(rs.getString(1));

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get Validation Errors of a JobId and RuleId: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Validation Errors of a JobId and RuleId: "+e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<String> getDistinctTasksOfJob(String jobId) {

		List<String> retList = null;

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to get Distinct Rule ids of Tasks");

		try {

			con = getConnection();

			String query="SELECT distinct rule_id from tasks where job_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, Integer.parseInt(jobId));

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();

				while (rs.next()) {

					retList.add(Integer.toString(rs.getInt(1)));

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get Distinct Rule ids of Tasks: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Distinct Rule ids of Tasks: "+e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<TaskStored> getFinishedTasks(String jobId, String ruleId) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		TaskStored retTask = null;

		List<TaskStored> retList = null; 

		logger.debug("Accessing DB to get Finished Tasks");

		try {

			con = getConnection();

			String query="SELECT success, record_identifier FROM tasks WHERE job_id=? AND rule_id=? AND status=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, Integer.parseInt(jobId));

			stmt.setInt(2,Integer.parseInt(ruleId));

			stmt.setString(3, "finished");

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<TaskStored>();

				while (rs.next()) {

					retTask = new TaskStored();

					retTask.setSuccess(rs.getBoolean(1));

					retTask.setRecordIdentifier(rs.getString(2));

					retList.add(retTask);

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get Finished Tasks: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Finished Tasks: "+e);

				}

			}

		}

		return retList;

	}

	@Override

	public void saveTasksBatch(List<TaskStored> tasks, Map<String,List<String>> groupByMap) {

		Connection con = null;

		PreparedStatement stmt = null, stmt1 = null;

		logger.debug("Accessing DB to save batch of tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";stmt = con.prepareStatement(query);

			stmt = con.prepareStatement(query);

			for (TaskStored t : tasks ) {

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

				stmt.setBoolean(2, t.getSuccess());

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

				stmt.setString(4, t.getEnded());

				stmt.setInt(5, Integer.parseInt(t.getJobId()));

				stmt.setInt(6, Integer.parseInt(t.getRuleId()));

				stmt.setString(7, t.getRecordIdentifier());

				stmt.setString(8, t.getRecordUrl());	

				stmt.addBatch();

		    }

		    stmt.executeBatch();

		    logger.debug("Tasks inserted: "+tasks.size());

		    if (!groupByMap.isEmpty()) {

		    	logger.debug("Inserting record's groupBy values..");

		    	for (Map.Entry<String, List<String>> entry : groupByMap.entrySet()) {

			    	query="INSERT INTO record_groupby(record_id, groupby, job_id) VALUES(?,?,?)";

			    	stmt1 = con.prepareStatement(query);

			    	for (String value :entry.getValue()) {

			    		stmt1.setString(1, entry.getKey());

			    		stmt1.setString(2, value);

			    		stmt1.setInt(3, Integer.parseInt(tasks.get(0).getJobId()));		

			    		stmt1.addBatch();

			    	}

		    	}

		    	stmt1.executeBatch();

//		    	logger.debug("groupBy values inserted: "+groupBy_values.size());		    	

		    }

		} catch (SQLException e) {

			logger.error("Error Accessing DB to save batch of tasks"+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks"+e);

				}

			}

			if (stmt1 != null) {

				try {

					stmt1.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks"+e);

				}

			}			

		}

	}

	@Override

	public void saveTasks(List<TaskStored> tasks, List<String> groupBy_values) {

		Connection con = null;

		PreparedStatement stmt = null, stmt1 = null;

		logger.debug("Accessing DB to save batch of tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";stmt = con.prepareStatement(query);

			stmt = con.prepareStatement(query);

			for (TaskStored t : tasks ) {

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

				stmt.setBoolean(2, t.getSuccess());

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

				stmt.setString(4, t.getEnded());

				stmt.setInt(5, Integer.parseInt(t.getJobId()));

				stmt.setInt(6, Integer.parseInt(t.getRuleId()));

				stmt.setString(7, t.getRecordIdentifier());

				stmt.setString(8, t.getRecordUrl());	

				stmt.addBatch();

		    }

		    stmt.executeBatch();

		    logger.debug("Tasks inserted: "+tasks.size());

		    if (groupBy_values != null) {

		    	logger.debug("Inserting record's groupBy values..");

		    	query="INSERT INTO record_groupby(record_id, groupby, job_id) VALUES(?,?,?)";

		    	stmt1 = con.prepareStatement(query);

		    	for (String value : groupBy_values) {

		    		stmt1.setString(1, tasks.get(0).getRecordIdentifier());

		    		stmt1.setString(2, value);

		    		stmt1.setInt(3, Integer.parseInt(tasks.get(0).getJobId()));		

		    		stmt1.addBatch();

		    	}

		    	stmt1.executeBatch();

		    	logger.debug("groupBy values inserted: "+groupBy_values.size());		    	

		    }

		} catch (SQLException e) {

			logger.error("Error Accessing DB to save batch of tasks"+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks"+e);

				}

			}

			if (stmt1 != null) {

				try {

					stmt1.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks"+e);

				}

			}			

		}

	}

	@Override

	public void saveTasks(Map<String, RuleStatus> scoreMapPerRule) {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to save batch of failed tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";stmt = con.prepareStatement(query);

			stmt = con.prepareStatement(query);

			for (Entry<String, RuleStatus> entry : scoreMapPerRule.entrySet()) {

				for (TaskStored t : entry.getValue().getFailedTasks() ) {

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

					stmt.setBoolean(2, t.getSuccess());

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

					stmt.setString(4, t.getEnded());

					stmt.setInt(5, Integer.parseInt(t.getJobId()));

					stmt.setInt(6, Integer.parseInt(t.getRuleId()));

					stmt.setString(7, t.getRecordIdentifier());

					stmt.setString(8, t.getRecordUrl());	

					stmt.addBatch();

				}

			}

		    int result = stmt.executeBatch().length;

		    logger.debug("Tasks inserted: "+ result);

		} catch (SQLException e) {

			logger.error("Error Accessing DB to save batch of failed tasks"+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of failed tasks"+e);

				}

			}

		}

	}

	@Override

	protected int getLastId() throws SQLException {

		return 1;

//		ResultSet rs = null;

//		Connection con = null;

//		PreparedStatement stmt = null;

//		int retId = -1;

//		logger.debug("Accessing DB to get Task's next available id");

//		try {

//			con = getConnection();

//			String query="SELECT currval(pg_get_serial_sequence(?,?)) FROM tasks";

//			stmt = con.prepareStatement(query);

//			stmt.setString(1, "tasks");

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

//			

//			rs = stmt.executeQuery();

//			if (rs!=null){

//				rs.next();

//				retId=rs.getInt(1);

//			}

//

//

//		} catch (SQLException e) {

//			logger.error("Error while accessing DB to get Task's next available id: "+e);

//		} finally {

//			if (stmt != null) {

//				try {

//					stmt.close();

//				} catch (SQLException e) {

//					logger.error("Error while accessing DB to get Task's next available id: "+e);

//				}

//			}

//		}

//		return retId;

	}

	@Override

	public void cleanTasks(int jobId) {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to delete unneeded tasks");

		try {

			con = getConnection();

			String query="DELETE FROM tasks WHERE job_id = ? AND success = ?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, jobId);

			stmt.setBoolean(2, true);

			stmt.executeUpdate();

			stmt.close();

		} catch (SQLException e) {

			logger.error("Error while Accessing DB to delete unneeded tasks: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while Accessing DB to delete unneeded tasks: "+e);

				}

			}

		}

	}

}

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

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

import java.util.List;

public interface RepositoryStoredDAO extends DAO<RepositoryStored> {

	public List<String> getBaseUrls();

}

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

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

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

public class RepositoryStoredDAOImpl extends AbstractDAO<RepositoryStored> implements RepositoryStoredDAO {

	@Override

	public List<String> getBaseUrls() {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<String> retList = null;

		logger.debug("Accessing DB to get all activated Repositories Stored");

		try {

			con = getConnection();

			String query="SELECT base_url FROM repositories WHERE activation_id is null";

			stmt = con.prepareStatement(query);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();				

				while (rs.next()) {

					retList.add(rs.getString(1));

				}				

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to get all activated Repositories Stored: "+e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to get all activated Repositories Stored: "+e);

				}

			}

		}

		return retList;

	}

	@Override

	protected PreparedStatement getUpdateStatement(RepositoryStored t,

			Connection con) throws SQLException {

		String query="UPDATE repositories 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(RepositoryStored t,

			Connection con) throws SQLException {

		String query="INSERT INTO repositories(base_url,activation_id) VALUES(?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

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

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

		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 RepositoryStored get(String id) {

		// TODO Auto-generated method stub

		return null;

	}

}

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

/**

 * 

 * @author Nikon Gasparis

 *

 */

public class RepositoryStored {

	private String baseUrl;

	private String activationId;

	public String getBaseUrl() {

		return baseUrl;

	}

	public void setBaseUrl(String baseUrl) {

		this.baseUrl = baseUrl;

	}

	public String getActivationId() {

		return activationId;

	}

	public void setActivationId(String activationId) {

		this.activationId = activationId;

	}