D-Net

{

  "type_source": "SVN", 

  "goal": "package -U -T 4C source:jar", 

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

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

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

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

  "name": "uoa-validator-admin"

}

package eu.dnetlib.validator.admin.actions.users;

import java.util.Map;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.config.Constants;

public class EditUser extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = -362061491263257713L;

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

	private UserProfile user;

	private Map<String, Object> session;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

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

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

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

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

		}

	}

	public UserProfile getUser() {

		return user;

	}

	public void setUser(UserProfile user) {

		this.user = user;

	}

	@Override

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

		this.session = session;

	}

}

package eu.dnetlib.validator.admin.actions.users;

import java.util.ArrayList;

import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

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, institution;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

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

			String activationId = null;

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

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

	}

	public String getInstitution() {

		return institution;

	}

	public void setInstitution(String institution) {

		this.institution = institution;

	}

}

package eu.dnetlib.validator.admin.actions.users;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

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 eu.dnetlib.validator.admin.actions.rulesets;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

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.getValidatorAdminAPI().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 eu.dnetlib.validator.admin.actions.rulesets;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

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

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

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.getValidatorAdminAPI().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 eu.dnetlib.validator.admin.actions.rulesets;

import java.util.Set;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

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

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

public class CreateRuleSet extends BaseValidatorAction {

	private static final long serialVersionUID = 5623461974078831740L;

	private Set<Integer> chosenContentRules = null;

	private Set<Integer> chosenUsageRules = null;	

	private String funct = null;

	private RuleSet ruleSet;

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

	public String execute() {

		this.clearErrorsAndMessages();

		try {

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

			ruleSet.setUsageRulesIds(chosenUsageRules);

			ruleSet.setContentRulesIds(chosenContentRules);

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

				this.getValidatorAdminAPI().storeRuleSet(ruleSet, false);

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

			}

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

				logger.debug("chosen content: " + chosenContentRules);

				this.getValidatorAdminAPI().storeRuleSet(ruleSet, true);

				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.isEmpty())||(chosenUsageRules == null || chosenUsageRules.isEmpty()))

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

		if(funct == null)

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

	}

	public String getFunct() {

		return funct;

	}

	public void setFunct(String funct) {

		this.funct = funct;

	}	

	public Set<Integer> getChosenContentRules() {

		return chosenContentRules;

	}

	public void setChosenContentRules(Set<Integer> chosenContentRules) {

		this.chosenContentRules = chosenContentRules;

	}

	public Set<Integer> getChosenUsageRules() {

		return chosenUsageRules;

	}

	public void setChosenUsageRules(Set<Integer> chosenUsageRules) {

		this.chosenUsageRules = chosenUsageRules;

	}

	public RuleSet getRuleSet() {

		return ruleSet;

	}

	public void setRuleSet(RuleSet ruleSet) {

		this.ruleSet = ruleSet;

	}

}	

package eu.dnetlib.validator.admin.actions.rulesets;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

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

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

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.constants.TypesAndTableNames;

public class GetRules extends BaseValidatorAction {

	private static final long serialVersionUID = 3336444896590055688L;

	private int setId = -1;

	private List<Rule> rulesContent;

	private List<Rule> rulesUsage;

	private Set<Integer> ruleIdsContent;

	private Set<Integer> ruleIdsUsage;

	private List<String> deployEnvironments;

	private String funct = null;

	private RuleSet ruleSet;

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

	public String execute() {

		this.clearErrorsAndMessages();

		try {

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

			ruleIdsContent = new HashSet<Integer>();

			ruleIdsUsage = new HashSet<Integer>();

			rulesContent = new ArrayList<Rule>();

			rulesUsage = new ArrayList<Rule>();

			this.splitRules(this.getValidatorAdminAPI().getAllRules(),rulesContent, rulesUsage);

			this.deployEnvironments = TypesAndTableNames.deployEnvironments;

			if (setId == -1) {

				ruleSet = new RuleSet();

				ruleSet.setId(-1);

				funct = "create";

			} else {

				funct = "edit";

				ruleSet = this.getValidatorAdminAPI().getRuleSet(setId);

				ruleIdsContent=ruleSet.getContentRulesIds();

				ruleIdsUsage=ruleSet.getUsageRulesIds();

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

			}

			return Action.SUCCESS;

		}

		catch(Exception e) {

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

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

			reportException(e);

			return "exception";

		}

	}

	private void splitRules(List<Rule> totalRules, List<Rule> contentRules, List<Rule> usageRules) {

		logger.debug("splitting rules..");

		for (Rule rule : totalRules) {

			if (rule.getJob_type().equals("content")) {

				contentRules.add(rule);

			} else if (rule.getJob_type().equals("usage")) {

				usageRules.add(rule);

			}

		}

	}

	public String getFunct() {

		return funct;

	}

	public void setFunct(String funct) {

		this.funct = funct;

	}

	public RuleSet getRuleSet() {

		return ruleSet;

	}

	public void setRuleSet(RuleSet ruleSet) {

		this.ruleSet = ruleSet;

	}

	public int getSetId() {

		return setId;

	}

	public void setSetId(int setId) {

		this.setId = setId;

	}

	public List<Rule> getRulesContent() {

		return rulesContent;

	}

	public void setRulesContent(List<Rule> rulesContent) {

		this.rulesContent = rulesContent;

	}

	public List<Rule> getRulesUsage() {

		return rulesUsage;

	}

	public void setRulesUsage(List<Rule> rulesUsage) {

		this.rulesUsage = rulesUsage;

	}

	public Set<Integer> getRuleIdsContent() {

		return ruleIdsContent;

	}

	public void setRuleIdsContent(Set<Integer> ruleIdsContent) {

		this.ruleIdsContent = ruleIdsContent;

	}

	public Set<Integer> getRuleIdsUsage() {

		return ruleIdsUsage;

	}

	public void setRuleIdsUsage(Set<Integer> ruleIdsUsage) {

		this.ruleIdsUsage = ruleIdsUsage;

	}

	public List<String> getDeployEnvironments() {

		return deployEnvironments;

	}

	public void setDeployEnvironments(List<String> deployEnvironments) {

		this.deployEnvironments = deployEnvironments;

	}

}

package eu.dnetlib.validator.admin.actions.help;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

@SuppressWarnings("serial")

public class HelpPage extends BaseValidatorAction{

}

package eu.dnetlib.validator.admin.actions.login;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

@SuppressWarnings("serial")

public class ForgotPasswordPage extends BaseValidatorAction{

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Map;

import org.apache.struts2.interceptor.SessionAware;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

@SuppressWarnings("serial")

public class LoginPage extends BaseValidatorAction implements SessionAware{

	@Override

	public String execute() throws Exception {

		this.clearErrorsAndMessages();

		String email = (String) session.get("email");

		if ( email!=null && !email.trim().isEmpty() )

			return INPUT;

		return SUCCESS;

	}

	private Map<String, Object> session;

	@Override

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

		this.session = session;		

	}

}

package eu.dnetlib.validator.admin.actions.login;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

public class ResetPassword extends BaseValidatorAction {

	private static final long serialVersionUID = -4565098546731325693L;

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

	private String password, repassword, securityCode;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("reseting password with security code " + securityCode);

			this.getUserAPI().resetPassword(this.getSecurityCode(), this.getPassword());

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

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error reseting password with security code " + securityCode, e);

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

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		try {

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

				this.addFieldError("securityCode", this.getText("resetPassword.wrongSecurityCode"));

				return;

			}

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

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

				return;

			}

		} catch (Exception e) {

			this.addActionError("");

		}

	}

	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 getSecurityCode() {

		return securityCode;

	}

	public void setSecurityCode(String securityCode) {

		this.securityCode = securityCode;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Map;

import com.opensymphony.xwork2.Action;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.Interceptor;

import eu.dnetlib.validator.admin.api.UserApi;

import eu.dnetlib.validator.admin.api.ValidatorAdminAPI;

import eu.dnetlib.validator.admin.config.Constants;

public class AdminInterceptor implements Interceptor {

	private static final long serialVersionUID = -172948943490485824L;

	private UserApi userAPI = null;

	private ValidatorAdminAPI validatorAdminAPI = null;

//	private Logger logger = Logger.getLogger(AdminInterceptor.class);

	@Override

	public void destroy() {

	}

	@Override

	public void init() {

	}

	@Override

	public String intercept(ActionInvocation actionInvocation) throws Exception {

		Map<String, Object> session = actionInvocation.getInvocationContext().getSession();

		String auth = (String) session.get(Constants.loggedInField);

		if (this.getUserAPI().isAdmin(auth) || this.getValidatorAdminAPI().userIsMasterAdmin(auth) || this.getValidatorAdminAPI().userIsSecondaryAdmin(auth))

			return actionInvocation.invoke();

		else

			return Action.LOGIN;

	}

	public UserApi getUserAPI() {

		return userAPI;

	}

	public void setUserAPI(UserApi userAPI) {

		this.userAPI = userAPI;

	}

	public ValidatorAdminAPI getValidatorAdminAPI() {

		return validatorAdminAPI;

	}

	public void setValidatorAdminAPI(ValidatorAdminAPI validatorAdminAPI) {

		this.validatorAdminAPI = validatorAdminAPI;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Map;

import java.util.regex.Pattern;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.ServletResponseAware;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.config.Constants;

public class Login extends BaseValidatorAction implements SessionAware, ServletResponseAware {

	private static final long serialVersionUID = -6021271413570776229L;

	private String email_username, password_login;

	private boolean rememberme;

	private Map<String, Object> session;

	private HttpServletResponse response;

	private String url;

	private String params;

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

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			if(this.email_username == null || this.email_username.trim().equals(""))

				return "login";	

			logger.debug("logging-in user " + this.getEmail());

			session.put(Constants.loggedInField, this.getEmail());

			session.put("email", this.getEmail());

			if (this.getUserAPI().isAdmin(email_username) || this.getValidatorAdminAPI().userIsMasterAdmin(email_username))

				session.put("isAdmin", "true");

			if (this.getValidatorAdminAPI().userIsMasterAdmin(email_username))

				session.put("isAdmin", "true");

			if (this.getValidatorAdminAPI().userIsSecondaryAdmin(email_username))

				session.put("isAdmin", "true");

			this.addActionMessage("Logged-in successfully");

			if (url != null && (url.equals("/go2login") || url.equals("/Login") || url.equals("/portalLogin"))) {

				url = "";

				return "welcome";

			}

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error logging-in user " + this.getEmail(), e);

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

			reportException(e);

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		try {

			if(this.email_username == null || this.email_username.trim().equals(""))

				return;

			String username = this.email_username;

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

				logger.debug("user logged in using username");

				this.email_username = this.getUserAPI().getEmailFromUsername(this.getEmail());

			}

			if (this.email_username == null) {

				this.email_username = username;

				this.addActionError(this.getText("login.userNotExists"));

				return;

			}

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

				this.email_username = username;

				this.addActionError(this.getText("login.userNotExists"));

				return;

			}

			if (!this.getUserAPI().isUserActivated(this.getEmail())) {

				this.email_username = username;

				this.addActionError(this.getText("login.notActivated"));

				return;

			}

			if (!this.getUserAPI().correctCreds(this.getEmail(), this.getPassword_login())) {

				this.email_username = username;

				this.addActionError(this.getText("login.incorrectCreds"));

				return;

			}

		} catch (Exception e) {

			logger.error("", e);

			this.addActionError(e.toString());

			reportException(e);

		}

	}

	public String getEmail() {

		return email_username;

	}

	public void setEmail_username(String email_username) {

		this.email_username = email_username;

	}

	public String getPassword_login() {

		return password_login;

	}

	public void setPassword_login(String password_login) {

		this.password_login = password_login;

	}

	@Override

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

		this.session = session;

	}

	public void setRememberme(boolean rememberme) {

		this.rememberme = rememberme;

	}

	public boolean isRememberme() {

		return rememberme;

	}

	public void setServletResponse(HttpServletResponse response) {

		this.response = response;

	}

	public HttpServletResponse getServletResponse() {

		return response;

	}

	public String getUrl() {

		return url;

	}

	public void setUrl(String url) {

		this.url = url;

	}

	public String getParams() {

		return params;

	}

	public void setParams(String params) {

		this.params = params;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Map;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.config.Constants;

public class Logout extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = -5304052800228900726L;

	private Map<String, Object> session;

	public String execute() {

		this.clearErrorsAndMessages();

		session.remove(Constants.loggedInField);

		session.remove("email");

		session.remove("isAdmin");

		this.addActionMessage("Logged-out successfully");

		return Action.SUCCESS;

	}

	@Override

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

		this.session = session;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Calendar;

import java.util.Map;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.codec.binary.Hex;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.ServletRequestAware;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.config.Constants;

public class PortalLogin extends BaseValidatorAction implements ServletRequestAware, SessionAware {

	private static final long serialVersionUID = -6312800103845446815L;

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

	private HttpServletRequest request;

	private Map<String, Object> session;

	private String user, ip, valid, signature;

	private String key;

	private String email;

	public void validate() {

		this.clearErrors();

		logger.debug("validating log-in from portal link " + user + ", " + ip + ", " + valid + ", " + signature);

		if (user == null || ip == null || valid == null) {

			this.addActionError(this.getText("login.manual"));

			return;

		}

		if (user.trim().equals("") || ip.trim().equals("") || valid.trim().equals("")) {

			this.addActionError(this.getText("login.manual"));

			return;

		}

		long millisUntil = 0;

		try {

			millisUntil = Long.parseLong(valid);

		} catch (Exception e) {

			logger.error("", e);

			this.addActionError(this.getText("login.manual"));

			return;

		}

		try {

			if (!signatureIsValid((user + ip + valid).trim(), signature.trim())) {

				logger.debug("signature was not valid");

				this.addActionError(this.getText("login.manual"));

				return;

			}

		} catch (Exception e) {

			logger.error("", e);

			this.addActionError(this.getText("login.manual"));

			return;

		}

		Calendar cal = Calendar.getInstance();

		if (cal.getTime().getTime() > millisUntil) {

			logger.debug("link has expired current-time: "+cal.getTime().getTime()+" link-time: "+millisUntil);

			this.addActionError(this.getText("login.manual"));

			return;

		}

		if (!ip.trim().equals(request.getRemoteAddr().trim())) {

			logger.debug("ips are different "+ip+" "+request.getRemoteAddr());

			this.addActionError(this.getText("login.manual"));

			return;

		}

		try {

//			if (isModeLdap())

				this.email = this.getUserAPI().getEmailFromUsername(user);

			if (this.email == null) {

				this.email = "";

				this.addActionError(this.getText("login.userNotExists"));

				return;

			}

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

				this.email = "";

				this.addActionError(this.getText("login.userNotExists"));

				return;

			}

			if (!this.getUserAPI().isUserActivated(this.getEmail())) {

				this.email = "";

				this.addActionError(this.getText("login.notActivated"));

				return;

			}

		} catch (Exception e) {

			logger.error("", e);

			this.addActionError(e.toString());

		}

	}

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("logging-in from portal link " + user + ", " + ip + ", " + valid + ", " + signature);

			session.put(Constants.loggedInField, this.getEmail());

			session.put("email", this.getEmail());

			if (this.getUserAPI().isAdmin(email))

				session.put("isAdmin", "true");

			this.addActionMessage("Logged-in successfully");

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error logging-in from portal link " + user + ", " + ip + ", " + valid + ", " + signature, e);

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

			reportException(e);

			return "exception";

		}

	}

	public boolean signatureIsValid(String message, String signature) throws Exception {

		byte[] encode = Hex.decodeHex(new String(Base64.decodeBase64(signature.getBytes())).toCharArray());

		SecretKeySpec key = new SecretKeySpec(this.key.getBytes(), "HmacSHA1");

		Mac mac = Mac.getInstance(key.getAlgorithm());

		mac.init(key);

		byte[] myEncode = mac.doFinal(message.getBytes());

		logger.debug("given encode: "+new String(encode)+" my-encode: "+new String(myEncode));

		if (encode.length != myEncode.length)

			return false;

		for (int i = 0; i < encode.length; i++)

			if (encode[i] != myEncode[i])

				return false;

		return true;

	}

	public void setServletRequest(HttpServletRequest request) {

		this.request = request;

	}

	public HttpServletRequest getServletRequest() {

		return request;

	}

	@Override

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

		this.session = session;

	}

	public String getUser() {

		return user;

	}

	public void setUser(String user) {

		this.user = user;

	}

	public String getIp() {

		return ip;

	}

	public void setIp(String ip) {

		this.ip = ip;

	}

	public String getValid() {

		return valid;

	}

	public void setValid(String valid) {

		this.valid = valid;

	}

	public String getSignature() {

		return signature;

	}

	public void setSignature(String signature) {

		this.signature = signature;

	}

	public String getKey() {

		return key;

	}

	public void setKey(String key) {

		this.key = key;

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(String email) {

		this.email = email;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

public class SendPassword extends BaseValidatorAction {

	private static final long serialVersionUID = 7540821478579531671L;

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

	private String email;

	public String execute() {

		this.clearErrorsAndMessages();

		try {

			logger.debug("sending password to user " + email);

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

			to.add(this.getEmail());

			String securityCode = this.getUserAPI().prepareResetPassword(this.getEmail());

			this.getEmailer().sendMail(to, this.getText("forgotPassword.mail.Subject"), this.getText("forgotPassword.mail.Body1") + ": " + this.getValBaseUrl() + "/resetPassword.action?securityCode=" + securityCode + "\n\n" + this.getText("forgotPassword.mail.Body2") + ": " + securityCode, false, null);

			this.addActionMessage(this.getText("forgotPassword.message"));

			return Action.SUCCESS;

		} catch (Exception e) {

			logger.error("error sending password to user " + email, e);

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

			return "exception";

		}

	}

	public void validate() {

		this.clearErrors();

		try {

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

				this.addActionError(this.getText("login.userNotExists"));

				return;

			}

//			if (!this.getUserAPI().isUserActivated(this.getEmail())) {

//				this.addActionError(this.getText("login.notActivated"));

//				return;

//			}

		} catch (Exception e) {

			this.addActionError(e.toString());

		}

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(String email) {

		this.email = email;

	}

}

package eu.dnetlib.validator.admin.actions.login;

import java.util.Map;

import com.opensymphony.xwork2.Action;

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.Interceptor;

import eu.dnetlib.validator.admin.config.Constants;

public class AuthenticationInterceptor implements Interceptor {

	private static final long serialVersionUID = 977098762082596481L;

	@Override

	public void destroy() {

	}

	@Override

	public void init() {

	}

	@Override

	public String intercept(ActionInvocation actionInvocation) throws Exception {

		Map<String, Object> session = actionInvocation.getInvocationContext().getSession();

		String auth = (String) session.get(Constants.loggedInField);

		if (auth == null) {

			return Action.LOGIN;

		}

		return actionInvocation.invoke();

	}

}

package eu.dnetlib.validator.admin.actions;

import com.opensymphony.xwork2.Action;

public class DummyAction extends BaseValidatorAction {

	private static final long serialVersionUID = 4105253794510714980L;

	public String execute() {

		return Action.SUCCESS;

	}

}

package eu.dnetlib.validator.admin.actions.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 eu.dnetlib.validator.admin.actions.rules;

import java.util.List;

import java.util.Set;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

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

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

import eu.dnetlib.validator.admin.api.ValidatorAdminException;

import eu.dnetlib.validator.admin.constants.TypesAndTableNames;

public class PrepareAddRule extends BaseValidatorAction {

	private static final long serialVersionUID = -8414397033694574297L;

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

	private String type;

	private Boolean forCris, forUsage = false;

	private List<String> labels;

	private String jobType;

	private Set<String> entityTypes;

	private List<Rule> rules;

	public String execute() {

		this.clearErrorsAndMessages();

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

		logger.debug("cris:  " + forCris);

		entityTypes = TypesAndTableNames.getCrisEntities().keySet();

		if (jobType.equals("usage"))

			forUsage = true; 

		try {

			labels = getValidatorAdminAPI().getRuleLabels(type, forUsage, forCris);

		} catch (ValidatorAdminException e) {

			return Action.ERROR;

		}

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

			try {

				rules = this.getValidatorAdminAPI().getAllRules();

			} catch (ValidatorAdminException e) {

				return Action.ERROR;

			}

		}

		return Action.SUCCESS;

	}

	public List<String> getLabels() {

		return labels;

	}

	public void setLabels(List<String> labels) {

		this.labels = labels;

	}

	public String getType() {

		return type;

	}

	public String getJobType() {

		return jobType;

	}

	public void setJobType(String jobType) {

		this.jobType = jobType;

	}

	public void setType(String type) {

		this.type = type;

	}

	public List<Rule> getRules() {

		return rules;

	}

	public void setRules(List<Rule> rules) {

		this.rules = rules;

	}

	public Set<String> getEntityTypes() {

		return entityTypes;

	}

	public void setEntityTypes(Set<String> entityTypes) {

		this.entityTypes = entityTypes;

	}

	public Boolean getForCris() {

		return forCris;

	}

	public void setForCris(Boolean forCris) {

		this.forCris = forCris;

	}

}

package eu.dnetlib.validator.admin.actions.rules;

import org.apache.log4j.Logger;

import com.opensymphony.xwork2.Action;

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

import eu.dnetlib.validator.admin.actions.BaseValidatorAction;

public class AddRule extends BaseValidatorAction {

	private static final long serialVersionUID = -4636737264204104816L;

	private String[] inputs;

	private String type, jobType;

	private boolean forCris;