D-Net

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 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.service.utils.Constants;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import eu.dnetlib.api.functionality.ValidatorService;

import org.json.JSONException;

import org.json.JSONObject;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Component;

import org.springframework.web.bind.annotation.PathVariable;

import javax.annotation.PostConstruct;

public class ValidatorApiImpl implements ValidatorApi{

    @Autowired

    private MonitorApiImpl monitorApi;

    /*@Autowired

    @Qualifier("validatorServiceLocator")*/

    private ServiceLocator<ValidatorService> validatorServiceLocator;

    private ValidatorService getValidationService() {

        return this.validatorServiceLocator.getService();

    }

    public ServiceLocator<ValidatorService> getValidatorServiceLocator() {

        return validatorServiceLocator;

    }

    public void setValidatorServiceLocator(ServiceLocator<ValidatorService> validatorServiceLocator) {

        this.validatorServiceLocator = validatorServiceLocator;

    }

    private Map<String, List<RuleSet>> rulesetMap = new ConcurrentHashMap<String, List<RuleSet>>();

    @PostConstruct

    private void loadRules(){

        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<RuleSet> ruleSets = new ArrayList<RuleSet>();

                        ruleSets.add(ruleSet);

                        rulesetMap.put(key, ruleSets);

                    }

                }

            }

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

    }

    @Override

    public void submitJobForValidation(JobForValidation jobForValidation) {

        try {

            this.getValidationService().submitValidationJob(jobForValidation);

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

    }

    @Override

    public void reSubmitJobForValidation(String jobId) throws JSONException {

        JSONObject jsonObject = new JSONObject();

        jsonObject.put("jobId",jobId);

        jsonObject.put("groupBy","all");

        StoredJob job = monitorApi.getJobSummary(jsonObject.toString());

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

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

        RuleSet ruleSet = null;

        for (List<RuleSet> 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<RuleSet> getRuleSets() {

        return rulesetMap.get(Constants.VALIDATION_MODE_DATA);

    }

    @Override

    public List<String> getSetsOfRepository(@PathVariable("url") String url) {

        try {

            return OaiTools.getSetsOfRepo(url);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

}