D-Net

package eu.dnetlib.validator.web.api.impls;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.log4j.Logger;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

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.validator.web.api.ValidatorWebApi;

import eu.dnetlib.validator.web.api.ValidatorWebException;

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

/**

 * 

 * @author Nikon Gasparis

 *

 */

@Transactional(propagation = Propagation.REQUIRED)

public class ValidatorWebApiImpl implements ValidatorWebApi {

	private ServiceLocator<ValidatorService> validatorService = null;

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

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

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

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

	public void start(){

	}

	@Override

	public boolean userOverridesRepoRegistration(String user)

			throws ValidatorWebException {

		logger.debug("checking if user " + user + " overrides repo registration procedures");

		if (this.masterAdmins.contains(user) || this.secondaryAdmins.contains(user)) {

			logger.debug("overrides");

			return true;

		} else {

			logger.debug("not overrides");

			return false;

		}

	}

	@Override

	public StoredJob getJobSummary(int jobId, String groupBy)

			throws ValidatorWebException {

		try {

			logger.info("getting job summary for id: " + jobId);

			return validatorService.getService().getStoredJob(jobId, groupBy);

		} catch (ValidatorServiceException e) {

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

			throw new ValidatorWebException(e);

		}

	}

	@Override

	public List<StoredJob> getJobsOfUser(String user, String jobType, Integer offset, Integer limit, String dateFrom, String dateTo) throws ValidatorWebException {

		try {

			logger.debug("getting jobs of user " + user);

			List<StoredJob> jobs;

			if (this.userOverridesRepoRegistration(user))

				jobs = validatorService.getService().getStoredJobs(null, jobType, offset, limit, null, null);

			else

				jobs = validatorService.getService().getStoredJobs(user, jobType, offset, limit, null, null);

			return jobs;

		} catch (Exception e) {

			logger.error("Error getting jobs of user " + user, e);

			throw new ValidatorWebException(e);

		}

	}

	@Override

	public int getJobsTotalNumberOfUser(String user, String jobType) throws ValidatorWebException {

		try {

			logger.debug("getting jobs of user " + user);

			int sum;

			if (this.userOverridesRepoRegistration(user))

				sum = validatorService.getService().getStoredJobsTotalNumber(null, jobType);

			else

				sum = validatorService.getService().getStoredJobsTotalNumber(user, jobType);

			return sum;

		} catch (Exception e) {

			logger.error("Error getting jobs of user " + user, e);

			throw new ValidatorWebException(e);

		}

	}

	@Deprecated

	public Map<String, List<StoredJob>> getJobsOfUserSplitted(String user) throws ValidatorWebException {

		try {

			logger.info("getting jobs of user " + user);

			Map< String, List<StoredJob>> jobsSplitted = new HashMap< String, List<StoredJob>>();

			List<StoredJob> jobs = null;

	//		userMail,jobType, offset, limit

			if (this.userOverridesRepoRegistration(user))

				jobs = validatorService.getService().getStoredJobs(null, null, 0, 5, null, null);

			else

				jobs = validatorService.getService().getStoredJobs(user, null, 0, 5, null, null);

			List<StoredJob> regList, compList, workflowList;

			regList = new ArrayList<StoredJob>();	

			compList = new ArrayList<StoredJob>();	

			workflowList = new ArrayList<StoredJob>();	

			for (StoredJob job : jobs) {

				if (job.getJobType().equals("Registration Request"))

					regList.add(job);

				else if (job.getJobType().equals("Compatibility Test"))

					compList.add(job);

				else if (job.getJobType().equals("Workflow Request"))

					workflowList.add(job);

			}				

			jobsSplitted.put("Registration Request", regList);

			jobsSplitted.put("Compatibility Test", compList);

			jobsSplitted.put("Workflow Request", workflowList);

			return jobsSplitted;

		} catch (Exception e) {

			logger.error("Error getting jobs of user " + user, e);

			throw new ValidatorWebException(e);

		}

	}

	@Override

	public Map<String, String> getRuleSetsMap(String deployEnvironment) throws ValidatorWebException {

		Map<String, String> map = new LinkedHashMap<String, String>();

		logger.info("Getting rulesets map");

		List<RuleSet> ruleSets;

		try {

			ruleSets = validatorService.getService().getRuleSets();

			for(RuleSet ruleSet : ruleSets)

			{

				if (ruleSet.getVisibility() != null && ruleSet.getVisibility().contains(deployEnvironment))

					map.put(ruleSet.getGuidelinesAcronym(), ruleSet.getName());

			}

		} catch (Exception e) {

			logger.error("Error getting rulesets map", e);

			throw new ValidatorWebException(e);

		}

		return map;

	}

	@Override

	public RuleSet getRuleSet(String acronym) throws ValidatorWebException {

		logger.info("Getting ruleset with acronym: " + acronym);

		RuleSet ruleSet = null;

		try {

			for(RuleSet rSet : validatorService.getService().getRuleSets())

			{

				if (rSet.getGuidelinesAcronym().equals(acronym))

					ruleSet = rSet;

			}

			return ruleSet;

		} catch (Exception e) {

			logger.error("Error getting ruleset", e);

			throw new ValidatorWebException(e);

		}

	}

	@Override

	public void submitValidationJob(JobForValidation job)

			throws ValidatorWebException {

		logger.info("Submitting validation job");

		try {

			validatorService.getService().submitValidationJob(job);

		} catch (Exception e) {

			logger.error("Submitting validation job", e);

			throw new ValidatorWebException(e);

		}

	}

	@Override

	public void reSubmitValidationJob(JobForValidation job, Set<Integer> rules)

			throws ValidatorWebException {

		logger.info("Re-Submitting validation job");

		try {

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

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

			RuleSet ruleSet = this.getRuleSet(job.getDesiredCompatibilityLevel());

			for (int ruleId : rules) {

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

			validatorService.getService().submitValidationJob(job);

		} catch (Exception e) {

			logger.error("Re-Submitting validation job", e);

			throw new ValidatorWebException(e);

		}

	}

	public ServiceLocator<ValidatorService> getValidatorService() {

		return validatorService;

	}

	public void setValidatorService(

			ServiceLocator<ValidatorService> validatorService) {

		this.validatorService = validatorService;

	}

	@Override

	public boolean userIsMasterAdmin(String user)

			throws ValidatorWebException {

		logger.debug("checking if user " + user + " is master admin");

		if (this.masterAdmins.contains(user)) {

			logger.debug("is master admin");

			return true;

		} else {

			logger.debug("isn't master admin");

			return false;

		}

	}

	@Override

	public boolean userIsSecondaryAdmin(String user)

			throws ValidatorWebException {

		logger.debug("checking if user " + user + " is secondary admin");

		if (this.secondaryAdmins.contains(user)) {

			logger.debug("is secondary admin");

			return true;

		} else {

			logger.debug("isn't secondary admin");

			return false;

		}

	}

	public void setMasterAdmins(String masterAdmins) {

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

		for (String recp : recps) {

			recp = recp.trim();

			this.masterAdmins.add(recp);

		}

	}

	public void setSecondaryAdmins(String secondaryAdmins) {

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

		for (String recp : recps) {

			recp = recp.trim();

			this.secondaryAdmins.add(recp);

		}

	}

	public void setBlacklistedUsers(String blacklistedUsers) {

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

		for (String recp : recps) {

			recp = recp.trim();

			this.blacklistedUsers.add(recp);

		}

	}

	public boolean isUserBlacklisted(String email) throws ValidatorWebException {

		logger.debug("checking if user " + email + " is blacklisted");

		if (this.blacklistedUsers.contains(email)) {

			logger.debug("is blacklisted");

			return true;

		} else {

			logger.debug("isn't blacklisted");

			return false;

		}

	}

}