D-Net

package eu.dnetlib.validator.service.impl;

import eu.dnetlib.domain.functionality.validator.RuleSet;

import eu.dnetlib.domain.functionality.validator.StoredJob;

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.commons.dao.rules.RulesDAO;

import eu.dnetlib.validator.commons.dao.rules.RulesetsDAO;

import eu.dnetlib.validator.engine.ValidatorException;

import eu.dnetlib.validator.engine.data.Rule;

import eu.dnetlib.validator.engine.execution.Job;

import eu.dnetlib.validator.service.impls.ValidatorRestore;

import eu.dnetlib.validator.service.impls.providers.OAIPMHRecordProvider;

import eu.dnetlib.validator.service.impls.providers.OAIPMHSinglePageVerbProvider;

import eu.dnetlib.validator.service.impls.rules.ChainRule;

import eu.dnetlib.validator.service.impls.rules.RuleTypes;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

	private Validator validator;

	private RulesetsDAO rulesetsDao;

	private RulesDAO rulesDao;

	private ValidatorRestore valRestore;

			logger.info("auto-restoring OpenAire Validator is enabled..");

			List<StoredJob> jobs = valRestore.deleteUncompleted();

			valRestore.restartJobs(jobs);

			logger.info("finished restoring OpenAire Validator..");

		} else {

			logger.info("auto-restoring OpenAire Validator is disabled..");

		}

			throws ValidatorException {

		try {

		} catch (Exception e) {

			logger.error("error getting job summary for job " + jobId, e);

			throw new ValidatorException(e);

		}

	}

	}

	public List<StoredJob> getStoredJobs(String userMail, String jobType,

										 Integer offset, Integer limit, String dateFrom, String dateTo, String jobStatus)

			throws ValidatorException {

			logger.error("error Getting jobs of user " + userMail, e);

			throw new ValidatorException(e);

		}

	}

	public int getStoredJobsTotalNumber(String userMail, String jobType)

			throws ValidatorException {

	}

	public int getStoredJobsTotalNumber(String userMail, String jobType, String jobStatus)

			throws ValidatorException {

			logger.error("error Getting jobs sum of user " + userMail, e);

			throw new ValidatorException(e);

		}

	}

		try {

		} catch (Exception e) {

			logger.error("error Getting rulesets ", e);

			throw new ValidatorException(e);

		}

	}

					ruleIdsForBlacklist = ruleset.getContentRulesIds();

					ruleIdsContent.addAll(ruleIdsForBlacklist);

				}

			Properties props = new Properties();

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

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

			newJob.setUserEmail("Workflow Service");

			newJob.setContentJobStatus("ongoing");

			newJob.setUsageJobStatus("none");

			newJob.setJobType("Workflow Request");

			newJob.setDuration("--");

			newJob.setBaseUrl(mdstoreId);

			newJob.setRules(ruleIdsContent);

			newJob.setGroupByXpath(groupBy);

			newJob.setMetadataPrefix("oai_dc");

			newJob.setId(-1);

			int jobIdStored = jobsDao.save(newJob);

			Set<Rule> rulesContent = new HashSet<Rule>();

			for (Integer ruleId : ruleIdsContent){

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

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

				else {

			}

			listenerContent.setJobSubmittedId(jobIdStored);

			listenerContent.setJobSubmittedUser("Workflow Service");

			listenerContent.setGroupBy_xpath(groupBy);

			listenerContent.setValidationType("content");

			listenerContent.setInternalJobsSum(workers);

			dnetListener.setBlackboardHandler(blackboardHandler);

			dnetListener.setJobStatusUpdateInterval(jobStatusUpdateInterval);

			dnetListener.setValidatorManager(this);

			dnetListener.setGroupBy(groupBy);

			}

				dnetListener.setEnableOutputToRS(true);

		} catch (Exception e) {

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

			throw new ValidatorException(e);

		}

	}

				for (RuleSet ruleset : rulesetsDao.getRuleSets(job.getDesiredCompatibilityLevel())) {

					job.setSelectedContentRules(ruleset.getContentRulesIds());

					job.setSelectedUsageRules(ruleset.getUsageRulesIds());

				}

				logger.debug("Chosen set: OpenAIRE For Thematic + Institutional Repositories");

				logger.debug("Setting METADATA_PREFIX to: oai_openaire");

				job.setMetadataPrefix("oai_openaire");

			} else if (

					job.getDesiredCompatibilityLevel().toLowerCase().matches("^openaire\\d.\\d$") ||

//					job.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire3.0") ||

//					job.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire4.0") ||

				logger.debug("Chosen set: OpenAIRE For Literature Repositories");

				logger.debug("Setting METADATA_PREFIX to: oai_dc");

				job.setMetadataPrefix("oai_dc");

					// job.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire2.0_data")) {

				logger.debug("Setting METADATA_PREFIX to: oai_datacite");

				job.setMetadataPrefix("oai_datacite");

					// job.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire3.0_cris")) {

				logger.debug("Setting METADATA_PREFIX to: oai_CERIF_openaire");

				job.setMetadataPrefix("oai_CERIF_openaire");

				logger.error("Cannot set metadata prefx for " + job.getDesiredCompatibilityLevel() + " guidelines");

			StoredJob newJob = new StoredJob(job);

			int contentJobs = 0;

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

			Map<String,Set<Integer>> verbRuleMap = null;

			String validationType = "";

				contentJobs = 1;

				newJob.setContentJobStatus("ongoing");

			} else {

				newJob.setContentJobStatus("none");

			}

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

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

				Set<Integer> old,temp = null;

					eu.dnetlib.domain.functionality.validator.Rule ruleStored = rulesDao.get(id);

					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(ruleStored.getId());

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

			        }else{

			        	logger.debug("Verb exists");

			            old.add(ruleStored.getId());

			        }

				validationType +="U";

				totalRules.addAll(job.getSelectedUsageRules());

				newJob.setUsageJobStatus("ongoing");

			} else {

				newJob.setUsageJobStatus("none");

			Map<String, Set<Rule>> entityChosenRulesMap = null;

			Map<String, Set<Rule>> entityChosenRulesMapReferential = null;

			if (job.isCris()) {

				entityChosenRulesMapReferential = new HashMap<>();

				newJob.setGroupByXpath("//header/setSpec");

				contentJobs = entityChosenRulesMap.keySet().size() + entityChosenRulesMapReferential.keySet().size();

				newJob.setCris(true);

				newJob.setSelectedCrisEntities(job.getSelectedCrisEntities());

				newJob.setCrisReferentialChecks(job.isCrisReferentialChecks());

				newJob.setUpdateExisting(job.isUpdateExisting());

				newJob.setOfficialName(job.getOfficialName());

				newJob.setAdminEmails(job.getAdminEmails());

				newJob.setDatasourceId(job.getDatasourceId());

				newJob.setInterfaceId(job.getInterfaceId());

				newJob.setInterfaceIdOld(job.getInterfaceIdOld());

				newJob.setRepoType(job.getRepoType());

				newJob.setJobType("Compatibility Test");

			newJob.setId(-1);

			int jobIdStored = jobsDao.save(newJob);

			RegistrationListener regListener = null;

				regListener.setUserMail(job.getUserEmail());

				regListener.setDatasourceId(job.getDatasourceId());

				regListener.setInterfaceId(job.getInterfaceId());

			CompatibilityTestListener compTestListener = listenersManager.createCompTestListener();

			compTestListener.setValidationSet(job.getValidationSet());

			compTestListener.setGuidelines(job.getDesiredCompatibilityLevel());

			compTestListener.setTotalJobs(usageJobs + contentJobs);

				Set<Rule> rulesContent = new HashSet<Rule>();

				Properties props = new Properties();

				props.setProperty(OAIPMHRecordProvider.METADATA_PREFIX, newJob.getMetadataPrefix());

				props.setProperty(OAIPMHRecordProvider.RECORDS,Integer.toString(job.getRecords()));

				props.setProperty(OAIPMHRecordProvider.SET,job.getValidationSet());

				Job jobContent = null;

				ValidatorJobListener listenerContent = listenersManager.createListener();

				listenerContent.setJobSubmittedUser(job.getUserEmail());

				listenerContent.setGroupBy_xpath(newJob.getGroupByXpath());

				listenerContent.setValidationType("content");

				listenerContent.setInternalJobsSum(contentJobs);

					logger.debug("Submiting job for cris.");

					logger.debug("Total content jobs: " + contentJobs);

					jobContent = new Job(jobIdStored, 4, rulesContent, props);

					// validator.submitJobForCris(jobContent, entityChosenRulesMap, entityChosenRulesMapReferential, listenerContent, compTestListener);

					// send cris validation to Guideline team member. Could be moved into MemoryThreadValidator.submitJobForCris method

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

					recipientsMailAddr.add("andreas.czerniak@uni-bielefeld.de");

					emailer.sendMail( recipientsMailAddr, "CrisJob submitting", "baseUrl: " + job.getBaseUrl() , false, recipientsMailAddr);

				} else {

					for (Integer ruleId : job.getSelectedContentRules()){

						//special behaviour type of rule is chain

							rulesContent.add(chainRule);

					}

					jobContent = new Job(jobIdStored, 1, rulesContent, props);

					} else {

						validator.submitJob(jobContent, 1, listenerContent, compTestListener);

					}

			}

			if (job.getSelectedUsageRules() != null) {

				ValidatorJobListener listenerUsage = listenersManager.createListener();

				listenerUsage.setJobSubmittedId(jobIdStored);

				listenerUsage.setValidationType("usage");

				listenerUsage.setJobSubmittedUser(job.getUserEmail());

				listenerUsage.setInternalJobsSum(usageJobs);

				List <Job> jobsUsage = new ArrayList<Job>();

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

					Properties pros = new Properties();

					pros.setProperty(OAIPMHSinglePageVerbProvider.VERB,entry.getKey());

					pros.setProperty(OAIPMHSinglePageVerbProvider.BASEURL, job.getBaseUrl());

					Set<Rule> rulesUsage = new HashSet<Rule>();

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

						eu.dnetlib.domain.functionality.validator.Rule tempRule = rulesDao.get(ruleId);

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

						rulesUsage.add((Rule)this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), tempRule.getId()));

					}

					jobsUsage.add(new Job(jobIdStored, 2, rulesUsage, pros));

				}

				for (Job jobUsage : jobsUsage ) {

					} else {

						validator.submitJob(jobUsage, 1, listenerUsage, compTestListener);

					}

				}

			}

		}

	}

	private void prepareCrisJobs(JobForValidation job,

			Map<String, Set<Rule>> entityChosenRulesMap,

		logger.debug("Selected Entities: " + job.getSelectedCrisEntities());

		for (String entity : RuleTypes.getEntities().keySet()) {

			logger.debug("checking entity: " + entity);

			Set<Rule> rulesBasic = new HashSet<Rule>();

			Set<Rule> rulesReferential = new HashSet<Rule>();

			if (job.getSelectedCrisEntities().contains(entity)) {

				logger.debug("entity: " + entity + " is selected");

				for (eu.dnetlib.domain.functionality.validator.Rule rule : rulesDao.getAllRulesByJobTypeEntityType("content", entity)) {

					if (job.getSelectedContentRules().contains(rule.getId())) {

						eu.dnetlib.domain.functionality.validator.Rule tempRule=rulesDao.get(rule.getId());

						if (rule.getName().contains("Relationship")) {

							if (job.isCrisReferentialChecks()) {

								rulesReferential.add((Rule) this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), tempRule.getId()));

							}

						} else {

							rulesBasic.add((Rule) this.getRuleClassInstanceByType(tempRule.getType(), tempRule.getConfiguration(), tempRule.getId()));

						}

					}

				}

				logger.debug("Basic rules: " + rulesBasic.size());

				logger.debug("Referential rules: " + rulesReferential.size());

				entityChosenRulesMap.put(RuleTypes.getSetOfEntity(entity), rulesBasic);

				if (job.isCrisReferentialChecks() && !rulesReferential.isEmpty())

					entityChosenRulesMapReferential.put(RuleTypes.getSetOfEntity(entity), rulesReferential);

			} else {

				logger.debug("entity: " + entity + " is not selected");

			}

		}

		logger.debug("Return entities: " + entityChosenRulesMap.keySet());

			logger.debug("error getting rule object of type "+type+" classname=null");

		else {

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

				properties.putAll(pros.getProperties());

				return (Rule) clazz.getConstructor(new Class[]{Properties.class,Integer.TYPE}).newInstance(properties,id);

			} catch (Exception e) {

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

	}

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

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

			rules_chain.add(chainRule1);

		} else {

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

			rules_chain.add(chainRule2);

		} else {

		Properties chainPros = new Properties();

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

	}

	public Validator getValidator() {

		return validator;

	}

	public ListenersManager getListenersManager() {

		return listenersManager;

	}

	public void setListenersManager(ListenersManager listenersManager) {

		this.listenersManager = listenersManager;

	}

		this.validator = validator;

	}

	public JobsDAO getJobsDao() {

		return jobsDao;

	public void setJobsDao(JobsDAO jobsDao) {

		this.jobsDao = jobsDao;

	public RulesetsDAO getRulesetsDao() {

		return rulesetsDao;

	public void setRulesetsDao(RulesetsDAO rulesetsDao) {

		this.rulesetsDao = rulesetsDao;

	public RulesDAO getRulesDao() {

		return rulesDao;

	public void setRulesDao(RulesDAO rulesDao) {

		this.rulesDao = rulesDao;

		return valRestore;

	}

	public void setValRestore(ValidatorRestore valRestore) {

		this.valRestore = valRestore;

	}