package eu.dnetlib.repo.manager.service.controllers; import eu.dnetlib.api.functionality.ValidatorServiceException; import eu.dnetlib.domain.functionality.validator.StoredJob; import eu.dnetlib.repo.manager.service.utils.OaiTools; import eu.dnetlib.repo.manager.shared.InterfaceInformation; import eu.dnetlib.repo.manager.shared.ValidationServiceException; import gr.uoa.di.driver.util.ServiceLocator; import eu.dnetlib.domain.functionality.validator.JobForValidation; import eu.dnetlib.domain.functionality.validator.RuleSet; import eu.dnetlib.repo.manager.shared.Constants; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import eu.dnetlib.api.functionality.ValidatorService; import org.apache.log4j.Logger; import org.json.JSONException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.springframework.web.bind.annotation.PathVariable; import javax.annotation.PostConstruct; import javax.annotation.Resource; @Component public class ValidatorApiImpl implements ValidatorApi{ @Autowired private MonitorApiImpl monitorApi; @Resource(name = "validatorServiceLocator") private ServiceLocator validatorServiceLocator; private ValidatorService getValidationService() { return this.validatorServiceLocator.getService(); } public ServiceLocator getValidatorServiceLocator() { return validatorServiceLocator; } public void setValidatorServiceLocator(ServiceLocator validatorServiceLocator) { this.validatorServiceLocator = validatorServiceLocator; } private Map> rulesetMap = new ConcurrentHashMap>(); private static final Logger LOGGER = Logger .getLogger(ValidatorApiImpl.class); @PostConstruct private void loadRules(){ LOGGER.debug("PostConstruct method! Load rules!"); try { for (RuleSet ruleSet : getValidationService().getRuleSets()) { if (ruleSet.getVisibility() != null && ruleSet.getVisibility().contains("development")) { String key = ""; if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_data$")) key = Constants.VALIDATION_MODE_DATA; else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0$") || ruleSet.getGuidelinesAcronym().equals("driver")) key = Constants.VALIDATION_MODE_LITERATURE; else if (ruleSet.getGuidelinesAcronym().matches("^openaire[1-9].0_cris$")) key = Constants.VALIDATION_MODE_CRIS; if (rulesetMap.containsKey(key)) rulesetMap.get(key).add(ruleSet); else { List ruleSets = new ArrayList(); ruleSets.add(ruleSet); rulesetMap.put(key, ruleSets); } } } } catch (ValidatorServiceException e) { e.printStackTrace(); } } @Override public void submitJobForValidation(JobForValidation jobForValidation) { LOGGER.debug("Submit job for validation with id : " + jobForValidation.getDatasourceId()); try { this.getValidationService().submitValidationJob(jobForValidation); } catch (ValidatorServiceException e) { e.printStackTrace(); } } @Override public void reSubmitJobForValidation(String jobId) throws JSONException { LOGGER.debug("Resubmit validation job with id : " + jobId); StoredJob job = monitorApi.getJobSummary(jobId,"all"); Set contentRules = new HashSet(); Set usageRules = new HashSet(); RuleSet ruleSet = null; for (List ruleSets : this.rulesetMap.values()) { for (RuleSet rSet : ruleSets) if (rSet.getGuidelinesAcronym().equals(job.getDesiredCompatibilityLevel())) { ruleSet = rSet; break; } } for (int ruleId : job.getRules()) { if (ruleSet.getContentRulesIds().contains(ruleId)) contentRules.add(ruleId); else if (ruleSet.getUsageRulesIds().contains(ruleId)) usageRules.add(ruleId); } if (!contentRules.isEmpty()) job.setSelectedContentRules(contentRules); if (!usageRules.isEmpty()) job.setSelectedUsageRules(usageRules); this.submitJobForValidation(job); } @Override public List getRuleSets(@PathVariable("mode") String mode) { LOGGER.info("Getting rulesets for mode: " + mode); return rulesetMap.get(mode); } @Override public List getSetsOfRepository(@PathVariable("url") String url) { LOGGER.debug("Getting sets of repository with url : " + url); try { return OaiTools.getSetsOfRepo(url); } catch (Exception e) { e.printStackTrace(); } return null; } @Override public boolean identifyRepo(@PathVariable("url") String url) { LOGGER.debug("Identify repository with url : " + url); try { return OaiTools.identifyRepository(url); } catch (Exception e) { LOGGER.error("Error while identifying repository with url: " + url, e); return false; } } @Override public RuleSet getRuleSet(@PathVariable("acronym") String acronym) { LOGGER.debug("Getting ruleset with acronym : " + acronym); RuleSet ruleSet = null; try { for (List ruleSets : this.rulesetMap.values()) { for (RuleSet rSet : ruleSets) if (rSet.getGuidelinesAcronym().equals(acronym)) { ruleSet = rSet; break; } } return ruleSet; } catch (Exception e) { LOGGER.error("Error getting ruleset", e); return null; } } @Override public List getStoredJobsNew(String user, String jobType, Integer offset, Integer limit, String dateFrom, String dateTo, String validationStatus) throws ValidatorServiceException { return getValidationService().getStoredJobsNew(user, jobType, offset, limit, dateFrom, dateTo, validationStatus); } @Override public int getStoredJobsTotalNumberNew(String user, String jobType, String validationStatus) throws ValidatorServiceException { return getValidationService().getStoredJobsTotalNumberNew(user, jobType, validationStatus); } @Override public InterfaceInformation getInterfaceInformation(@PathVariable("baseUrl") String baseUrl) throws ValidationServiceException { try { LOGGER.debug("Getting interface information with url: " + baseUrl); InterfaceInformation interfaceInformation = new InterfaceInformation(); interfaceInformation.setIdentified(this.identifyRepo(baseUrl)); if (interfaceInformation.isIdentified()) interfaceInformation.setSets(this.getSetsOfRepository(baseUrl)); return interfaceInformation; } catch (Exception e) { LOGGER.error("Error getting interface information with url: " + baseUrl, e); // emailUtils.reportException(e); throw new ValidationServiceException("login.generalError", ValidationServiceException.ErrorCode.GENERAL_ERROR); } } }