D-Net

<module>

   <name>uoa-madgik-validator</name>

   <source type="SVN">http://svn-public.driver.research-infrastructures.eu/driver/dnet11/modules/uoa-madgik-validator/trunk</source>

   <goal>package</goal>

   <mail>antleb@di.uoa.gr, nikonas@di.uoa.gr, kiatrop@di.uoa.gr</mail>

   <sonar>no</sonar>

   <deploy>

       <RepositoryId>dnet-snapshot</RepositoryId>

       <RepositoryURL>http://maven.research-infrastructures.eu/nexus/content/repositories/dnet-snapshots</RepositoryURL>

   </deploy>

   <nigthly>no</nigthly>

</module>

package gr.uoa.di.validatorweb.actions.browsejobs;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.RequestAware;

import com.opensymphony.xwork2.Action;

public class FetchValidationErrors extends BaseValidatorAction implements RequestAware {

	private static final long serialVersionUID = -6630957729077819377L;

	private int ruleId;

	private int jobId;

	private String urlPrefix;

	private List<String> valErrors;

	private Logger logger = Logger.getLogger( FetchValidationErrors.class);

	public String execute() throws Exception {

		logger.debug("fetching val errors");

		this.clearErrorsAndMessages();

		valErrors = this.getOpenAIREValidator().getValidationErrors(jobId, ruleId);

		request.put("jsonization", jsonise(valErrors));

		return Action.SUCCESS;

	}

	private String jsonise(List<String> errors) {

		StringBuilder sb = new StringBuilder();

		sb.append("{\"errors\":[");

		for (int i=0; i < errors.size(); i++) {

			if (i > 0)

				sb.append(", ");

			if (errors.get(i) == null){

				sb.append("{\"description\":").append("\"No record available\"");

				sb.append(", \"url\":\"").append("#").append("\"");

			} else {

				sb.append("{\"description\":\"").append(errors.get(i)).append("\"");

				sb.append(", \"url\":\"").append(createUrls(errors.get(i))).append("\"");

			}

			sb.append("}");

		}

		sb.append("]}");

		return sb.toString();

	}

	private String createUrls(String label){

		StringBuilder sb = new StringBuilder();

		sb.append(urlPrefix).append(label);		

		return sb.toString();

	}

	public int getRuleId() {

		return ruleId;

	}

	public void setRuleId(int ruleId) {

		this.ruleId = ruleId;

	}

	public int getJobId() {

		return jobId;

	}

	public void setJobId(int jobId) {

		this.jobId = jobId;

	}

	public List<String> getValErrors() {

		return valErrors;

	}

	public void setValErrors(List<String> valErrors) {

		this.valErrors = valErrors;

	}

	public void setUrlPrefix(String urlPrefix) {

		this.urlPrefix = urlPrefix;

	}

	public String getUrlPrefix() {

		return urlPrefix;

	}

	private Map<String, Object> request;

	@Override

	public void setRequest(Map<String, Object> request) {

		this.request = request;		

	}

}

package gr.uoa.di.validatorweb.actions.browsejobs;

import gr.uoa.di.validator.api.OpenAIREValidatorException;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class DatabaseCurator extends BaseValidatorAction {

	private static final long serialVersionUID = -1868055729316139461L;

	private static final Logger logger = Logger.getLogger(DatabaseCurator.class);

	private String inDate = null;

	private String mode;

	public String getMode() {

		return mode;

	}

	public void setMode(String mode) {

		this.mode = mode;

	}

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			this.getOpenAIREValidator().deleteOldJobs(inDate,mode);

		} catch (OpenAIREValidatorException e) {

			logger.error("Error deleting old jobs", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "input-problem";

		}

		return Action.SUCCESS;

	}

	public void validate() {

		this.clearErrors();

		if (!mode.equalsIgnoreCase("uncompleted_only")){

			if (inDate == null) {

				this.addActionError(this.getText("wrongFieldValue"));

				return;

			}

			SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

			if (inDate.trim().length() != dateFormat.toPattern().length()) {

				this.addActionError(this.getText("wrongFieldValue"));

				return;

			}

			dateFormat.setLenient(false);

			try {

				dateFormat.parse(inDate.trim());

			} catch (ParseException pe) {

				this.addActionError(this.getText("wrongFieldValue"));

				return;

			}

		}

	}

	public String getInDate() {

		return inDate;

	}

	public void setInDate(String inDate) {

		this.inDate = inDate;

	}

}

package gr.uoa.di.validatorweb.actions.browsejobs;

import gr.uoa.di.validator.dao.JobSubmitted;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import gr.uoa.di.validatorweb.configs.Constants;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

public class PrepareJobBrowsing extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = 7391643068980907156L;

	private Logger logger = Logger.getLogger(PrepareJobBrowsing.class);

	private boolean enableCuration = false;

	private List<JobSubmitted> jobs;

	public List<JobSubmitted> getJobs() {

		return jobs;

	}

	public void setJobs(List<JobSubmitted> jobs) {

		this.jobs = jobs;

	}

	private Map<String, Object> session;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("preparing job browsing");

			jobs = this.getOpenAIREValidator().getJobsOfUser((String) session.get(Constants.loggedInField));

			enableCuration = getOpenAIREValidator().userOverridesRepoRegistration((String) session.get(Constants.loggedInField));

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error while preparing job browsing", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	@Override

	public void setSession(Map<String, Object> session) {

		this.session = session;

	}

	public void setEnableCuration(boolean enableCuration) {

		this.enableCuration = enableCuration;

	}

	public boolean isEnableCuration() {

		return enableCuration;

	}

}

package gr.uoa.di.validatorweb.actions.browsejobs;

import gr.uoa.di.validator.dao.Entry;

import gr.uoa.di.validator.dao.JobSubmitted;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class PrepareSummary extends BaseValidatorAction {

	private static final long serialVersionUID = -462318678652799883L;

	private String jobId, groupBy;

	private JobSubmitted job;

	private List<Entry> entries;

	private String urlPrefix = null;

	private String errorMessage = "";

	private String errorMessage0 = "";

	private List<String> groupBy_values;

	private String filteredScore;

	private static final Logger logger = Logger.getLogger(PrepareSummary.class);

	public String execute() {

		this.clearErrorsAndMessages();

		errorMessage = "";

		try {

			logger.debug("preparing job summary for job "+jobId);

			entries = this.getOpenAIREValidator().getJobSummary(jobId,groupBy);

			groupBy_values = this.getOpenAIREValidator().getDistinctGroupByValues(jobId);

			filteredScore = this.getOpenAIREValidator().getFilteredScore(jobId, groupBy);

			job = this.getOpenAIREValidator().getJobSubmitted(jobId);

//			String mtdPrfx = "oai_dc";

//			logger.debug("set of job: "+job.getSet());

//			if (job.getSet()!=null && job.getSet().equalsIgnoreCase("openaire_data"))

//				mtdPrfx = "oai_datacite";\

			urlPrefix = job.getRepo() + "?verb=GetRecord&metadataPrefix=" + job.getMetadata_prefix() +"&identifier=";

			if(entries == null || entries.size() == 0) {

				errorMessage=job.getError();

				errorMessage0 = getText("job.noTasks");

			}

			;

			return Action.SUCCESS;

		}

		catch(Exception e) {

			logger.error("Error redirecting to job", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public String getUrlPrefix() {

		return urlPrefix;

	}

	public void setUrlPrefix(String urlPrefix) {

		this.urlPrefix = urlPrefix;

	}

	public String getJobId() {

		return jobId;

	}

	public void setJobId(String jobId) {

		this.jobId = jobId;

	}

	public JobSubmitted getJob() {

		return job;

	}

	public void setJob(JobSubmitted job) {

		this.job = job;

	}

	public List<Entry> getEntries() {

		return entries;

	}

	public void setEntries(List<Entry> entries) {

		this.entries = entries;

	}

	public String getGroupBy() {

		return groupBy;

	}

	public void setGroupBy(String groupBy) {

		this.groupBy = groupBy;

	}

	public List<String> getGroupBy_values() {

		return groupBy_values;

	}

	public void setGroupBy_values(List<String> groupBy_values) {

		this.groupBy_values = groupBy_values;

	}

	public void setErrorMessage(String errorMessage) {

		this.errorMessage = errorMessage;

	}

	public String getErrorMessage() {

		return errorMessage;

	}

	public String getFilteredScore() {

		return filteredScore;

	}

	public void setFilteredScore(String filteredScore) {

		this.filteredScore = filteredScore;

	}

	public String getErrorMessage0() {

		return errorMessage0;

	}

	public void setErrorMessage0(String errorMessage0) {

		this.errorMessage0 = errorMessage0;

	}

}

package gr.uoa.di.validatorweb.actions;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class BugReporter extends BaseValidatorAction {

	private static final long serialVersionUID = -3331529072364646515L;

	private transient Logger logger = Logger.getLogger(BugReporter.class);

	private String ex = null;

	public String execute() {

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

		this.addActionError(this.getText("generic.error"));

		try {

			recipients.add(this.getValAdminEmail());

			String message = "An exception has occurred:\n"+ex;

			String subject = "Automatic Bug Report";

			this.getEmailer().sendMail(recipients, subject, message, false, null);

		} catch (Exception e) {

			logger.error("error sending error report", e);

		}

		return Action.SUCCESS;

	}

	public void setEx(String ex) {

		this.ex = ex;

	}

	public String getEx() {

		return ex;

	}

}

package gr.uoa.di.validatorweb.actions.users;

import gr.uoa.di.validator.api.user.UserProfileIS;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import gr.uoa.di.validatorweb.configs.Constants;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

public class EditUser extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = -362061491263257713L;

	private Logger logger = Logger.getLogger(EditUser.class);

	private String fname, lname, inst;

	public String getFname() {

		return fname;

	}

	public void setFname(String fname) {

		this.fname = fname;

	}

	public String getLname() {

		return lname;

	}

	public void setLname(String lname) {

		this.lname = lname;

	}

	public String getInst() {

		return inst;

	}

	public void setInst(String inst) {

		this.inst = inst;

	}

	private Map<String, Object> session;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("getting for edit user " + (String) session.get(Constants.loggedInField));

//			if (isModeLdap() || isModeOpenAIRE()) {

			if (isModeLdap()) {				

				UserProfileIS profile = (UserProfileIS) this.getUserAPI().getUser((String) session.get(Constants.loggedInField));

				fname = profile.getFname();

				lname = profile.getLname();

				inst = profile.getInstitution();

			}

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error getting for edit user " + (String) session.get(Constants.loggedInField), e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public String edit() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("editing user " + (String) session.get(Constants.loggedInField));

			this.getUserAPI().editUser((String) session.get(Constants.loggedInField), fname, lname, inst);

			this.addActionMessage(this.getText("editUser.success"));

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error editing user " + (String) session.get(Constants.loggedInField), e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	@Override

	public void setSession(Map<String, Object> session) {

		this.session = session;

	}

}

package gr.uoa.di.validatorweb.actions.users;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.ArrayList;

import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class Register extends BaseValidatorAction {

	private static final long serialVersionUID = 4906485913149844710L;

	private Logger logger = Logger.getLogger(Register.class);

	private String email, password, repassword;

	private String username, firstName, lastName;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("registering user " + email);

			String activationId = null;

			if (isModeLdap() || isModeOpenAIRE())

				activationId = this.getUserAPI().addUser(username, email, password, firstName, lastName);

			else

				activationId = this.getUserAPI().addUser(this.getEmail(), this.getPassword());

			this.addActionMessage((this.getText("registration.successful")));

			this.addActionMessage((this.getText("general.unblock") + " " + this.getEmailer().getFrom()));

			ArrayList<String> to = new ArrayList<String>();

			to.add(this.getEmail());

			this.getEmailer().sendMail(to, this.getText("registration.mail.subject"), this.getText("registration.mail.message") + ": " + this.getValBaseUrl() + "/activateAccount.action?activationId=" + activationId, false, null);

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error registering user " + email, e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		if (this.getEmail() == null || this.getEmail().length() == 0)

			this.addFieldError("email", this.getText("compulsoryField"));

		if (this.getPassword() == null || this.getPassword().length() == 0)

			this.addFieldError("password", this.getText("compulsoryField"));

		if (this.getRepassword() == null || this.getRepassword().length() == 0)

			this.addFieldError("repassword", this.getText("compulsoryField"));

		if (isModeLdap()) {

			if (this.getUsername() == null || this.getUsername().length() == 0)

				this.addFieldError("username", this.getText("compulsoryField"));

			if (this.getFirstName() == null || this.getFirstName().length() == 0)

				this.addFieldError("firstName", this.getText("compulsoryField"));

			if (this.getLastName() == null || this.getLastName().length() == 0)

				this.addFieldError("lastName", this.getText("compulsoryField"));

		}

		if (!this.getPassword().equals(this.getRepassword()))

			this.addFieldError("password", this.getText("identicalPasswords"));

		Pattern rfc2822 = Pattern.compile("^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$");

		if (!rfc2822.matcher(this.getEmail().trim().toLowerCase()).matches()) {

			this.addFieldError("email", this.getText("notValidEmail"));

		}

		try {

			if (this.getUserAPI().userExists(this.getEmail()))

				this.addFieldError("email", this.getText("userAlreadyExists"));

			if (isModeLdap() && this.getUserAPI().usernameExists(this.getUsername()))

				this.addFieldError("username", this.getText("userAlreadyExists"));

		} catch (Exception e) {

			this.addFieldError("email", this.getText("userAlreadyExists"));

		}

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(String email) {

		this.email = email;

	}

	public String getPassword() {

		return password;

	}

	public void setPassword(String password) {

		this.password = password;

	}

	public String getRepassword() {

		return repassword;

	}

	public void setRepassword(String repassword) {

		this.repassword = repassword;

	}

	public String getUsername() {

		return username;

	}

	public void setUsername(String username) {

		this.username = username;

	}

	public String getFirstName() {

		return firstName;

	}

	public void setFirstName(String firstName) {

		this.firstName = firstName;

	}

	public String getLastName() {

		return lastName;

	}

	public void setLastName(String lastName) {

		this.lastName = lastName;

	}

}

package gr.uoa.di.validatorweb.actions.users;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class ActivateAccount extends BaseValidatorAction {

	private static final long serialVersionUID = 4680016183168923054L;

	private Logger logger = Logger.getLogger(ActivateAccount.class);

	private String activationId;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("activating user account with activation id " + activationId);

			if (this.getUserAPI().activateUser(this.getActivationId()))

				this.addActionMessage(this.getText("registration.okAccountActivation"));

			else

				this.addActionMessage(this.getText("registration.okAccountAlreadyActivation"));

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error activating user account with activation id " + activationId, e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		if (this.getActivationId() == null || this.getActivationId().length() == 0) {

			this.addActionError(this.getText("noActivationId"));

			return;

		}

	}

	public String getActivationId() {

		return activationId;

	}

	public void setActivationId(String activationId) {

		this.activationId = activationId;

	}

}

package gr.uoa.di.validatorweb.actions.feedback;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

@SuppressWarnings("serial")

public class FeedBackPage extends BaseValidatorAction{

}

package gr.uoa.di.validatorweb.actions.feedback;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import gr.uoa.di.validatorweb.configs.Constants;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

public class SendFeedback extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = -4610293868659763433L;

	private Logger logger = Logger.getLogger(SendFeedback.class);

	private String reason, message;

	private Map<String, Object> session;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("sending feedback from user " + (String) session.get(Constants.loggedInField));

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

			recipients.add(this.getValAdminEmail());

			String message = "The following message was sent from " + (String) session.get(Constants.loggedInField) + "\n\n" + this.message;

			String subject = this.reason;

			this.getEmailer().sendMail(recipients, subject, message, false, null);

			this.addActionMessage(this.getText("feedback.success"));

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error sending feedback", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	@Override

	public void setSession(Map<String, Object> session) {

		this.session = session;

	}

	public String getReason() {

		return reason;

	}

	public void setReason(String reason) {

		this.reason = reason;

	}

	public String getMessage() {

		return message;

	}

	public void setMessage(String message) {

		this.message = message;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rulesets;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class DeleteRuleSet extends BaseValidatorAction {

	private static final long serialVersionUID = 4858147485197818532L;

	private int setId;

	private static final Logger logger = Logger.getLogger(DeleteRuleSet.class);

	public int getSetId() {

		return setId;

	}

	public void setSetId(int setId) {

		this.setId = setId;

	}

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("deleting rule set "+setId);

			this.getOpenAIREValidator().deleteRuleSet(setId);

			this.addActionMessage(this.getText("deleteRuleSet.success"));

			return Action.SUCCESS;

		}

		catch(Exception e) {

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

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

}

package gr.uoa.di.validatorweb.actions.admin.rulesets;

import gr.uoa.di.validator.dao.RuleSet;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class GetRuleSets extends BaseValidatorAction {

	private static final long serialVersionUID = -5220242100308666597L;

	private List<RuleSet> sets;

	private static final Logger logger = Logger.getLogger(GetRuleSets.class);

	public List<RuleSet> getSets() {

		return sets;

	}

	public void setSets(List<RuleSet> sets) {

		this.sets = sets;

	}

	public String execute() throws Exception {

		this.clearErrorsAndMessages();

		try {

			logger.debug("getting all rule sets");

			sets = this.getOpenAIREValidator().getRuleSetIdNames();

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("Error getting rule sets", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

}

package gr.uoa.di.validatorweb.actions.admin.rulesets;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class CreateRuleSet extends BaseValidatorAction {

	private static final long serialVersionUID = 5623461974078831740L;

	private String[] chosenContentRules = null;

	private String[] chosenUsageRules = null;	

	private String name = null;

	private String description = null;

	private String funct = null;

	private int setId = -1;

	private static final Logger logger = Logger.getLogger(CreateRuleSet.class);

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("creating a new rule set "+name);

			if(funct.equals("create")) {

				this.getOpenAIREValidator().createRuleSet(name, description, chosenContentRules,chosenUsageRules);

				this.addActionMessage(this.getText("createRuleSet.success"));

			}

			else if(funct.equals("edit")) {

				this.getOpenAIREValidator().editRuleSet(setId, name, description, chosenContentRules,chosenUsageRules);

				this.addActionMessage(this.getText("createRuleSet.success"));

			}

			return Action.SUCCESS;

		}

		catch(Exception e) {

			logger.error("Error creating/editing ruleset", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		if((chosenContentRules == null || chosenContentRules.length < 1)||(chosenUsageRules == null || chosenUsageRules.length < 1))

			this.addActionError(this.getText("createRuleSets.atLeastOneRule"));

		if(funct == null)

			this.addActionError(this.getText("uknownError"));

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public int getSetId() {

		return setId;

	}

	public void setSetId(int setId) {

		this.setId = setId;

	}

	public String getFunct() {

		return funct;

	}

	public void setFunct(String funct) {

		this.funct = funct;

	}	

	public String[] getChosenContentRules() {

		return chosenContentRules;

	}

	public void setChosenContentRules(String[] chosenContentRules) {

		this.chosenContentRules = chosenContentRules;

	}

	public String[] getChosenUsageRules() {

		return chosenUsageRules;

	}

	public void setChosenUsageRules(String[] chosenUsageRules) {

		this.chosenUsageRules = chosenUsageRules;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

}	

package gr.uoa.di.validatorweb.actions.admin.rulesets;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import gr.uoa.di.validatorweb.actions.compTest.RuleD;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class FetchRuleDescriptions extends BaseValidatorAction {

	private static final long serialVersionUID = -2095636309367991598L;

	private List<RuleD> rulesContent;

	private List<RuleD> rulesUsage;

	private String ruleSetDescription;

	private String ruleSetId;

	private static final Logger logger = Logger.getLogger(FetchRuleDescriptions.class);

	public String execute() {

		this.clearErrorsAndMessages();

		String ruleSetName = null;

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

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

		int id;

		try {

			id = Integer.parseInt(ruleSetId);

		} catch (NumberFormatException nfe) {

			// case of wrong url			

			id = -1;

		}

		try {

			ruleSetName = this.getOpenAIREValidator().getRuleSetName(id);

			//case of wrong given id

			if (ruleSetName == null) {

				id = -1;

			}

			if (id == -1) {

				ruleSetName = "All";

				ruleIdsContent = this.getOpenAIREValidator().getAllRuleIdsByJobType("content");

				ruleIdsUsage = this.getOpenAIREValidator().getAllRuleIdsByJobType("usage");

			} else { 

				ruleSetName = this.getOpenAIREValidator().getRuleSetName(id);			

				ruleIdsContent = this.getOpenAIREValidator().getRuleSetRuleIdsByJobType(id,"content");

				ruleIdsUsage = this.getOpenAIREValidator().getRuleSetRuleIdsByJobType(id,"usage");

			}

			rulesContent = this.getOpenAIREValidator().convertRuleIdsListToRuleDList(ruleIdsContent);

			rulesUsage = this.getOpenAIREValidator().convertRuleIdsListToRuleDList(ruleIdsUsage);	

			ruleSetDescription = "ruleSetInfo."+ruleSetName;

			logger.debug("ruleset descr " + ruleSetDescription);

			logger.debug("rulesContent" + rulesContent.size());

			logger.debug("rulesUsage" + rulesUsage.size());

			return Action.SUCCESS;

		}

		catch(Exception e) {

			logger.error("Error fetching rule descriptions", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public List<RuleD> getRulesContent() {

		return rulesContent;

	}

	public void setRulesContent(List<RuleD> rulesContent) {

		this.rulesContent = rulesContent;

	}

	public List<RuleD> getRulesUsage() {

		return rulesUsage;

	}

	public void setRulesUsage(List<RuleD> rulesUsage) {

		this.rulesUsage = rulesUsage;

	}

	public void setRuleSetDescription(String ruleSetDescription) {

		this.ruleSetDescription = ruleSetDescription;

	}

	public String getRuleSetDescription() {

		return ruleSetDescription;

	}

	public String getRuleSetId() {

		return ruleSetId;

	}

	public void setRuleSetId(String ruleSetId) {

		this.ruleSetId = ruleSetId;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rulesets;

import gr.uoa.di.validator.dao.RuleSet;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class GetRules extends BaseValidatorAction {

	private static final long serialVersionUID = 3336444896590055688L;

	private int setId = -1;

	private List<RuleS> rulesContent;

	private List<RuleS> rulesUsage;

	private List<String> ruleIdsContent;

	private List<String> ruleIdsUsage;

	private String funct = null;

	private String name = "";

	private String description = "";

	private static final Logger logger = Logger.getLogger(GetRules.class);

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("getting rules in rule set "+setId);

			if (setId == -1) {

				funct = "create";

				ruleIdsContent = new ArrayList<String>();

				rulesContent = this.getOpenAIREValidator().getAllRulesForPresentationByJobType("content");

				ruleIdsUsage = new ArrayList<String>();

				rulesUsage = this.getOpenAIREValidator().getAllRulesForPresentationByJobType("usage");			

			} else {

				funct = "edit";

				ruleIdsContent = this.getOpenAIREValidator().getRuleSetRuleIdsByJobType(setId,"content");

				rulesContent = this.getOpenAIREValidator().getAllRulesForPresentationByJobTypeByRuleSet(ruleIdsContent,"content");

				ruleIdsUsage = this.getOpenAIREValidator().getRuleSetRuleIdsByJobType(setId,"usage");

				rulesUsage = this.getOpenAIREValidator().getAllRulesForPresentationByJobTypeByRuleSet(ruleIdsContent,"usage");					

				RuleSet set = this.getOpenAIREValidator().getRuleSet(setId);

				name = set.getName();

				description = set.getDescription();

			}

			return Action.SUCCESS;

		}

		catch(Exception e) {

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

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getFunct() {

		return funct;

	}

	public void setFunct(String funct) {

		this.funct = funct;

	}

	public int getSetId() {

		return setId;

	}

	public void setSetId(int setId) {

		this.setId = setId;

	}

	public List<RuleS> getRulesContent() {

		return rulesContent;

	}

	public void setRulesContent(List<RuleS> rulesContent) {

		this.rulesContent = rulesContent;

	}

	public List<RuleS> getRulesUsage() {

		return rulesUsage;

	}

	public void setRulesUsage(List<RuleS> rulesUsage) {

		this.rulesUsage = rulesUsage;

	}

	public List<String> getRuleIdsContent() {

		return ruleIdsContent;

	}

	public void setRuleIdsContent(List<String> ruleIdsContent) {

		this.ruleIdsContent = ruleIdsContent;

	}

	public List<String> getRuleIdsUsage() {

		return ruleIdsUsage;

	}

	public void setRuleIdsUsage(List<String> ruleIdsUsage) {

		this.ruleIdsUsage = ruleIdsUsage;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rulesets;

public class RuleS {

	private String id;

	private String name;

	private boolean chosen = false;

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public boolean isChosen() {

		return chosen;

	}

	public void setChosen(boolean chosen) {

		this.chosen = chosen;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rules;

public class FieldPair {

	private String fieldName, fieldValue;

	public String getFieldName() {

		return fieldName;

	}

	public void setFieldName(String fieldName) {

		this.fieldName = fieldName;

	}

	public String getFieldValue() {

		return fieldValue;

	}

	public void setFieldValue(String fieldValue) {

		this.fieldValue = fieldValue;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rules;

import gr.uoa.di.validator.api.OpenAIREValidatorException;

import gr.uoa.di.validator.dao.RulePair;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class PrepareAddRule extends BaseValidatorAction {

	private static final long serialVersionUID = -8414397033694574297L;

	private Logger logger = Logger.getLogger(PrepareAddRule.class);

	private String type;

	private List<String> labels;

	private String[] jobTypes;

	private List<RulePair> rules;

	public String execute() {

		this.clearErrorsAndMessages();

		logger.debug("preparing to add rule of type " + type);

		try {

			labels = getOpenAIREValidator().getRuleLabels(type);

		} catch (OpenAIREValidatorException e) {

			return Action.ERROR;

		}

		try {

			jobTypes = getOpenAIREValidator().getJobTypesAsArray();

		} catch (OpenAIREValidatorException e) {

			return Action.ERROR;

		}

		if (type.equals("ChainRule")) {

			try {

				rules = this.getOpenAIREValidator().getAllRulesToRulePair();

			} catch (OpenAIREValidatorException e) {

				return Action.ERROR;

			}

		}

		return Action.SUCCESS;

	}

	public String[] getJobTypes() {

		return jobTypes;

	}

	public void setJobTypes(String[] jobTypes) {

		this.jobTypes = jobTypes;

	}

	public List<String> getLabels() {

		return labels;

	}

	public void setLabels(List<String> labels) {

		this.labels = labels;

	}

	public String getType() {

		return type;

	}

	public void setType(String type) {

		this.type = type;

	}

	public List<RulePair> getRules() {

		return rules;

	}

	public void setRules(List<RulePair> rules) {

		this.rules = rules;

	}

}

package gr.uoa.di.validatorweb.actions.admin.rules;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class AddRule extends BaseValidatorAction {

	private static final long serialVersionUID = -4636737264204104816L;

	private String[] inputs;

	private String type, jobType;

	private static final Logger logger = Logger.getLogger(AddRule.class);

	public String getJobType() {

		return jobType;

	}

	public void setJobType(String jobType) {

		this.jobType = jobType;

	}

	public String getType() {

		return type;

	}

	public void setType(String type) {

		this.type = type;

	}

	public String[] getInputs() {

		return inputs;

	}

	public void setInputs(String[] inputs) {

		this.inputs = inputs;

	}

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("adding rule of type "+type+" using user inputs");

			String ret = this.getOpenAIREValidator().addNewRule(this.type, this.jobType, inputs);

			if (ret != null) {

				this.addActionError(this.getText(ret));

				return "input-problem";

			}

			this.addActionMessage(this.getText("addRule.success"));

			return Action.SUCCESS;

		} catch(Exception e) {

			logger.error("Error adding rule", e);

			this.addActionError(this.getText("generic.error"));

			reportException(e);

			return "exception";

		}

	}

}

package gr.uoa.di.validatorweb.actions.admin.rules;

import gr.uoa.di.validator.api.OpenAIREValidatorException;

import gr.uoa.di.validatorweb.actions.BaseValidatorAction;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

public class PopulateRuleCategories extends BaseValidatorAction {

	private static final long serialVersionUID = 3845749201114926778L;

	private Logger logger = Logger.getLogger(PopulateRuleCategories.class);

	private List<String> ruleTypes;

	public List<String> getRuleTypes() {

		return ruleTypes;

	}

	public void setRuleTypes(List<String> ruleTypes) {

		this.ruleTypes = ruleTypes;

	}

	public String execute() {

		this.clearErrorsAndMessages();

		logger.debug("populating rule categories");

		try {