D-Net

{

  "type_source": "SVN", 

  "goal": "package -U source:jar", 

  "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-madgik-validator/trunk", 

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

  "mail": "antleb@di.uoa.gr, kiatrop@di.uoa.gr, nikonas@di.uoa.gr", 

  "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet4-snapshots", 

  "name": "uoa-madgik-validator"

}

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 Map<String,List<JobSubmitted>> 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;

	}

	public Map<String, List<JobSubmitted>> getJobs() {

		return jobs;

	}

	public void setJobs(Map<String, List<JobSubmitted>> jobs) {

		this.jobs = jobs;

	}

}

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

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

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

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

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

import java.io.File;

import java.io.FileOutputStream;

import java.util.List;

import org.apache.log4j.Logger;

import org.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

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

//			this.writeExcelDemo();

//			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";

		}

	}

	private void writeExcelDemo() throws OpenAIREValidatorException { 

	        //Blank workbook

	        XSSFWorkbook workbook = new XSSFWorkbook(); 

	        //Create a blank sheet

	        XSSFSheet sheet = workbook.createSheet("Datacite Report");

			int rownum = 0;

			Row row = sheet.createRow(rownum++);

			Cell cell = row.createCell(0);

			cell.setCellValue("Reponame");

			cell = row.createCell(1);

			cell.setCellValue("Rule name");

//			cell = row.createCell(2);

//			cell.setCellValue("Rule Desc");

			cell = row.createCell(2);

			cell.setCellValue("# of records tested");

			cell = row.createCell(3);

			cell.setCellValue("# of records failed");

			cell = row.createCell(4);

			cell.setCellValue("FAIL/SUCCESS");

			for (String groupBy : groupBy_values) {

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

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

				for (Entry entry : entries) {

					row = sheet.createRow(rownum++);

					cell = row.createCell(0);

					cell.setCellValue(groupBy);

					cell = row.createCell(1);

					cell.setCellValue(entry.getName());

//					cell = row.createCell(2);

//					cell.setCellValue(entry.getDescription());

					cell = row.createCell(2);

					cell.setCellValue(Integer.parseInt(entry.getSuccesses().split("/")[1]));

					cell = row.createCell(3);

					cell.setCellValue(Integer.parseInt(entry.getSuccesses().split("/")[0]));

					cell = row.createCell(4);

					if (Integer.parseInt(entry.getSuccesses().split("/")[1]) == Integer.parseInt(entry.getSuccesses().split("/")[0]))

						cell.setCellValue("SUCCESS");

					else

						cell.setCellValue("FAIL");

				}

			}

	        try

	        {

	            //Write the workbook in file system

	            FileOutputStream out = new FileOutputStream(new File("datacite_full.xlsx"));

	            workbook.write(out);

	            out.close();

	            System.out.println("howtodoinjava_demo.xlsx written successfully on disk.");

	        } 

	        catch (Exception e) 

	        {

	            e.printStackTrace();

	        }

	    }

	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;

	}

}

////This data needs to be written (Object[])

//Map<String, Object[]> data = new TreeMap<String, Object[]>();

////Reponame | #of records tested |Rule name | Rule Desc | FAIL/SUCCESS | # of records failed  

//data.put("1", new Object[] {"Reponame", "NAME", "LASTNAME"});

//data.put("2", new Object[] {1, "Amit", "Shukla"});

//data.put("3", new Object[] {2, "Lokesh", "Gupta"});

//data.put("4", new Object[] {3, "John", "Adwards"});

//data.put("5", new Object[] {4, "Brian", "Schultz"});

//  

////Iterate over data and write to sheet

//Set<String> keyset = data.keySet();

//int rownum = 0;

//for (String key : keyset)

//{

//    Row row = sheet.createRow(rownum++);

//    Object [] objArr = data.get(key);

//    int cellnum = 0;

//    for (Object obj : objArr)

//    {

//       Cell cell = row.createCell(cellnum++);

//       if(obj instanceof String)

//            cell.setCellValue((String)obj);

//        else if(obj instanceof Integer)

//            cell.setCellValue((Integer)obj);

//    }

//}

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().getRuleSets();

			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 shortName = null;

	private String description = null;

	private String guidelinesAcronym = null;

	private String visibility = 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, shortName, description, guidelinesAcronym, visibility, chosenContentRules,chosenUsageRules);

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

			}

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

				this.getOpenAIREValidator().editRuleSet(setId, name, shortName, description, guidelinesAcronym, visibility, 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;

	}

	public String getVisibility() {

		return visibility;

	}

	public void setVisibility(String visibility) {

		this.visibility = visibility;

	}

	public String getGuidelinesAcronym() {

		return guidelinesAcronym;

	}

	public void setGuidelinesAcronym(String guidelinesAcronym) {

		this.guidelinesAcronym = guidelinesAcronym;

	}

	public String getShortName() {

		return shortName;

	}

	public void setShortName(String shortName) {

		this.shortName = shortName;

	}

}	

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.validator.dao.Utilities;

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 = null;

	private String description = null;

	private String shortName = null;

	private String guidelinesAcronym = null;

	private String visibility = null;

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

				guidelinesAcronym = set.getGuidelinesAcronym();

				visibility = Utilities.convertListToString(set.getVisibility());

				shortName= set.getShortName();

			}

			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;

	}

	public String getGuidelinesAcronym() {

		return guidelinesAcronym;

	}

	public void setGuidelinesAcronym(String guidelinesAcronym) {

		this.guidelinesAcronym = guidelinesAcronym;

	}

	public String getVisibility() {

		return visibility;

	}

	public void setVisibility(String visibility) {

		this.visibility = visibility;

	}

	public String getShortName() {

		return shortName;

	}

	public void setShortName(String shortName) {

		this.shortName = shortName;

	}

}

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.constants.RuleTypes;

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

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

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

import java.util.List;

import java.util.Set;

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;