D-Net

package eu.dnetlib.repo.manager.service;

import eu.dnetlib.api.functionality.ValidatorService;

import eu.dnetlib.api.functionality.ValidatorServiceException;

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

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

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

import eu.dnetlib.repo.manager.shared.Constants;

import eu.dnetlib.repo.manager.shared.InterfaceInformation;

import eu.dnetlib.repo.manager.shared.ValidationServiceException;

import eu.dnetlib.repo.manager.utils.OaiTools;

import gr.uoa.di.driver.util.ServiceLocator;

import io.swagger.annotations.ApiParam;

import org.apache.log4j.Logger;

import org.json.JSONException;

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

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.security.access.prepost.PreAuthorize;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Service;

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

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

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

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

@Service("validatorService")

public class ValidatorApiImpl implements ValidatorApi {

    @Autowired

    private MonitorApiImpl monitorApi;

    @Resource(name = "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>>();

    private static final Logger LOGGER = Logger

            .getLogger(ValidatorApiImpl.class);

    @Autowired

    private EmailUtils emailUtils;

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

                        ruleSets.add(ruleSet);

                        rulesetMap.put(key, ruleSets);

                    }

                }

            }

        } catch (ValidatorServiceException e) {

            e.printStackTrace();

        }

    }

    @Override

    @PreAuthorize("hasRole('ROLE_USER') and #jobForValidation.userEmail == authentication.userInfo.email")

    public JobForValidation submitJobForValidation(@RequestBody JobForValidation jobForValidation) throws ValidatorServiceException {

        LOGGER.debug("Submit job for validation with id : " + jobForValidation.getDatasourceId());

        try {

            emailUtils.sendSubmitJobForValidationEmail(SecurityContextHolder.getContext().getAuthentication(),jobForValidation);

            this.getValidationService().submitValidationJob(jobForValidation);

        } catch (ValidatorServiceException e) {

            LOGGER.debug("Exception on submitJobForValidation" , e);

            emailUtils.reportException(e);

            throw e;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return jobForValidation;

    }

    @Override

    @PreAuthorize("hasRole('ROLE_USER') and #email == authentication.userInfo.email")

    public ResponseEntity<Object> reSubmitJobForValidation(@PathVariable("email") String email,

                                                           @PathVariable("jobId") String jobId) throws JSONException, ValidatorServiceException {

        LOGGER.debug("Resubmit validation job with id : " + jobId);

        StoredJob job = monitorApi.getJobSummary(jobId,"all");

        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);

        return new ResponseEntity<>("OK",HttpStatus.OK);

    }

    @Override

    public List<RuleSet> getRuleSets(@PathVariable("mode") String mode) {

        LOGGER.info("Getting rulesets for mode: " + mode);

        return rulesetMap.get(mode);

    }

    @Override

    public List<String> getSetsOfRepository(@RequestParam(value = "url", required = true) String url) {

        LOGGER.debug("Getting sets of repository with url : " + url);

        try {

            return OaiTools.getSetsOfRepo(url);

        } catch (Exception e) {

            LOGGER.debug("Exception on getSetsOfRepository" , e);

            emailUtils.reportException(e);

        }

        return null;

    }

    @Override

    public boolean identifyRepo(@RequestParam(value = "url", required = true) 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);

            emailUtils.reportException(e);

            return false;

        }

    }

    @Override

    public RuleSet getRuleSet(@PathVariable("acronym") String acronym) {

        LOGGER.debug("Getting ruleset with acronym : " + acronym);

        RuleSet ruleSet = null;

        try {

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

            emailUtils.reportException(e);

            return null;

        }

    }

    @Override

    @PreAuthorize("hasRole('ROLE_USER')")

    public List<StoredJob> getStoredJobsNew(@RequestParam("user") @ApiParam(value = "User email", required = true) String user,

                                            @RequestParam(value = "jobType", required = false)

                                            @ApiParam(value = "Equals to filter job type on validation history page") String jobType,

                                            @RequestParam("offset") @ApiParam(value = "Page number", required = true) String offset,

                                            @RequestParam(value = "limit", required = false,defaultValue = "10") @ApiParam(value = "Null value") String limit,

                                            @RequestParam(value = "dateFrom", required = false) @ApiParam(value = "Null value") String dateFrom,

                                            @RequestParam(value = "dateTo", required = false) @ApiParam(value = "Null value") String dateTo,

                                            @RequestParam("validationStatus") @ApiParam(value = "Equals to filter validation jobs", required = true) String validationStatus

                                            ) throws ValidatorServiceException {

        return getValidationService().getStoredJobsNew(user, jobType, Integer.parseInt(offset), Integer.parseInt(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(@RequestParam(value = "baseUrl", required = true) 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);

        }

    }

}