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

}

package eu.dnetlib.validator.commons.dao.users;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.validator.commons.dao.DAO;

import eu.dnetlib.validator.commons.dao.DaoException;

public interface UsersDAO extends DAO<UserProfile> {

	public boolean checkCorrectCreds(String email, String password) throws DaoException;

	public boolean isAdmin(String email) throws DaoException;

	public boolean isRepoAdmin(String email) throws DaoException;

	public boolean isActivated(String email) throws DaoException;

	public boolean activateUser(String activation_id) throws DaoException;

	public boolean userExists(String email) throws DaoException;

	public boolean usernameExists(String username) throws DaoException;

	public void prepareResetPassword(String uuid, String email) throws DaoException;

	public void ResetPassword(String activation_id, String password) throws DaoException;

	public UserProfile get(String email) throws DaoException;

}

package eu.dnetlib.validator.commons.dao.users;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import eu.dnetlib.domain.functionality.UserProfile;

import eu.dnetlib.validator.commons.dao.AbstractDAO;

import eu.dnetlib.validator.commons.dao.DaoException;

public class UsersDAOimpl extends AbstractDAO<UserProfile> implements UsersDAO {

	@Override

	protected PreparedStatement getUpdateStatement(UserProfile t, Connection con)

			throws SQLException {

		String query="UPDATE users SET email=?, institution=?, firstname=?, lastname=? WHERE username=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, t.getEmail());

		stmt.setString(2, t.getInstitution());

		stmt.setString(3, t.getFirstname());

		stmt.setString(4, t.getLastname());

		stmt.setString(5, t.getUsername());

		return stmt;

	}

	@Override

	protected PreparedStatement getInsertStatement(UserProfile t, Connection con)

			throws SQLException {

		String query="INSERT INTO users(email,password,institution,username,firstname,lastname,activation_id) VALUES(?,?,?,?,?,?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, t.getEmail());

		stmt.setString(2, t.getPassword());

		stmt.setString(3, t.getInstitution());

		stmt.setString(4, t.getUsername());

		stmt.setString(5, t.getFirstname());

		stmt.setString(6, t.getLastname());

		stmt.setString(7, t.getActivationId());		

		return stmt;

	}

	@Override

	protected PreparedStatement getDeleteStatement(int id, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	protected int getLastId() throws SQLException {

		// TODO Auto-generated method stub

		return 0;

	}

	@Override

	public UserProfile get(String email) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		UserProfile retUser = null;

		logger.debug("Accessing DB to get User with email: " + email);

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=? OR username=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1, email);

			stmt.setString(2, email);

			rs = stmt.executeQuery();

			if (rs!=null){

				if (rs.next()) {

					retUser = new UserProfile();

					retUser.setEmail(rs.getString("email"));

					retUser.setUsername(rs.getString("username"));

					retUser.setFirstname(rs.getString("firstname"));

					retUser.setLastname(rs.getString("lastname"));

					retUser.setInstitution(rs.getString("institution"));

					retUser.setActivationId(rs.getString("activation_id"));

				}				

			}

		} catch (Exception e) {

			logger.error("Error Accessing DB to get User.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error Accessing DB to get User.", e);

					throw new DaoException(e);

				}

			}

		}

		return retUser;

	}

	@Override

	public boolean activateUser(String activation_id) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to activate user");

		try {

			con = getConnection();

			String query="UPDATE users SET activation_id=? WHERE activation_id=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1, null);

			stmt.setString(2, activation_id);

			if (stmt.executeUpdate() > 0){

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while Accessing DB to activate user.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while Accessing DB to activate user.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public UserProfile get(int id) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public boolean checkCorrectCreds(String email, String password) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check correct credentials");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=? AND password=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			stmt.setString(2,password);

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check correct credentials.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check correct credentials.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isAdmin(String email) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is admin");

		try {

			con = getConnection();

			String query="SELECT * FROM admins WHERE username=? AND level=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			stmt.setString(2,"master");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check if user is admin.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is admin.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isRepoAdmin(String email) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is repoAdmin");

		try {

			con = getConnection();

			String query="SELECT * FROM admins WHERE username=? AND level=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			stmt.setString(2,"secondary");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check if user is repoAdmin.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is repoAdmin.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean isActivated(String email) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user is activated");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=? AND activation_id is null";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

//			stmt.setString(2,"NULL");

			rs = stmt.executeQuery();

			if (rs.next()){

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check if user is activated .", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user is activated .", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean userExists(String email) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user "+email+" exists");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE email=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,email);

			rs = stmt.executeQuery();

			if (rs.next()){

				logger.debug("user exists");

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check if user exists.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user exists.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public boolean usernameExists(String username) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to check if user "+ username +" exists");

		try {

			con = getConnection();

			String query="SELECT * FROM users WHERE username=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1,username);

			rs = stmt.executeQuery();

			if (rs.next()){

				logger.debug("user exists");

				return true;

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to check if user exists.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to check if user exists.", e);

					throw new DaoException(e);

				}

			}

		}

		return false;

	}

	@Override

	public void prepareResetPassword(String uuid, String email) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to prepare reset password");

		try {

			con = getConnection();

			String query="UPDATE users SET activation_id=? WHERE email=?";;

			stmt = con.prepareStatement(query);

			stmt.setString(1,uuid);

			stmt.setString(2,email);

			stmt.executeUpdate();

		} catch (Exception e) {

			logger.error("Error while accessing DB to prepare reset password.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to prepare reset password.", e);

					throw new DaoException(e);

				}

			}

		}

	}

	@Override

	public void ResetPassword(String uuid, String password) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to reset password");

		try {

			con = getConnection();

			String query="UPDATE users SET password=?, activation_id=? WHERE activation_id=?";;

			stmt = con.prepareStatement(query);

			stmt.setString(1,password);

			stmt.setString(2,null);

			stmt.setString(3,uuid);

			stmt.executeUpdate();

		} catch (Exception e) {

			logger.error("Error while accessing DB to reset password.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to reset password.", e);

					throw new DaoException(e);

				}

			}

		}

	}

}

package eu.dnetlib.validator.commons.dao;

public class DaoException extends Exception {

	/**

	 * 

	 * @author Nikon Gasparis

	 *

	 */

	private static final long serialVersionUID = 1030647214820156752L;

	public DaoException() {

		super();

	}

	public  DaoException(String message) {

		super(message);

	}

	public  DaoException(String message, Throwable cause) {

		super(message, cause);

	}

	public  DaoException(Throwable cause) {

		super(cause);

	}

}

package eu.dnetlib.validator.commons.dao;

public interface DAO<T> {

	public Integer save (T t) throws DaoException;

//	public String delete (T t);

	public String delete (int id) throws DaoException;

	public T get (int id) throws DaoException;

}

package eu.dnetlib.validator.commons.dao.tasks;

public class TaskStored {

	private String status, started, ended, valObjId, recordIdentifier, recordUrl;

	private int jobId, ruleId;

	private boolean success;

//	private RuleD rule;

	public String getRecordUrl() {

		return recordUrl;

	}

	public void setRecordUrl(String recordUrl) {

		this.recordUrl = recordUrl;

	}

	public String getStatus() { 

		return status;

	}

	public void setStatus(String status) {

		this.status = status;

	}

	public boolean getSuccess() {

		return success;

	}

	public void setSuccess(boolean success) {

		this.success = success;

	}

	public String getStarted() {

		return started;

	}

	public void setStarted(String started) {

		this.started = started;

	}

	public String getEnded() {

		return ended;

	}

	public void setEnded(String ended) {

		this.ended = ended;

	}

	public String getValObjId() {

		return valObjId;

	}

	public void setValObjId(String valObjId) {

		this.valObjId = valObjId;

	}

	public String getRecordIdentifier() {

		return recordIdentifier;

	}

	public void setRecordIdentifier(String recordIdentifier) {

		this.recordIdentifier = recordIdentifier;

	}

	public int getJobId() {

		return jobId;

	}

	public void setJobId(int jobId) {

		this.jobId = jobId;

	}

	public int getRuleId() {

		return ruleId;

	}

	public void setRuleId(int ruleId) {

		this.ruleId = ruleId;

	}

}

package eu.dnetlib.validator.commons.dao.tasks;

import eu.dnetlib.validator.commons.dao.DAO;

import eu.dnetlib.validator.commons.dao.DaoException;

import eu.dnetlib.validator.commons.dao.rules.RuleStatus;

import java.util.List;

import java.util.Map;

public interface TasksDAO extends DAO<TaskStored> {

	public List<TaskStored> getTasksOfJob(int id) throws DaoException;

	public List<String> getValidationErrors(int jobId, int ruleId) throws DaoException;

	public List<String> getDistinctTasksOfJob(int jobId) throws DaoException;

	public List<TaskStored> getFinishedTasks(int jobId, int ruleId) throws DaoException;

	public void saveTasks(List<TaskStored> tasksStored, List<String> sets) throws DaoException;

	public void cleanTasks(int jobId) throws DaoException;

	public void saveTasksBatch(List<TaskStored> tasks, Map<String, List<String>> groupByMap) throws DaoException;

	public void saveTasks(Map<Integer, RuleStatus> scoreMapPerRule) throws DaoException;

}

package eu.dnetlib.validator.commons.dao.tasks;

import eu.dnetlib.validator.commons.dao.AbstractDAO;

import eu.dnetlib.validator.commons.dao.DaoException;

import eu.dnetlib.validator.commons.dao.rules.RuleStatus;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

public class TasksDAOimpl extends AbstractDAO<TaskStored> implements TasksDAO{

	@Override

	protected PreparedStatement getUpdateStatement(TaskStored t, Connection con)

			throws SQLException {

		String query="UPDATE tasks set status=?, success=?, started=?, ended=?, record_url=? WHERE job_id=? AND rule_id=? AND record_identifier=?";

		PreparedStatement stmt = con.prepareStatement(query);

//		logger.debug("getting taskStored updateStatement");

		stmt.setString(1, t.getStatus());

		stmt.setBoolean(2, t.getSuccess());

		stmt.setString(3, t.getStarted());

		stmt.setString(4, t.getEnded());

		stmt.setString(5, t.getRecordUrl());	

		stmt.setInt(6, t.getJobId());

		stmt.setInt(7, t.getRuleId());

		stmt.setString(8, t.getRecordIdentifier());

		return stmt;

	}

	@Override

	protected PreparedStatement getInsertStatement(TaskStored t, Connection con) throws SQLException {

		String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

//		logger.debug("getting taskStored insertStatement");

		stmt.setString(1, t.getStatus());

		stmt.setBoolean(2, t.getSuccess());

		stmt.setString(3, t.getStarted());

		stmt.setString(4, t.getEnded());

		stmt.setInt(5, t.getJobId());

		stmt.setInt(6, t.getRuleId());

		stmt.setString(7, t.getRecordIdentifier());

		stmt.setString(8, t.getRecordUrl());		

		return stmt;

	}

	@Override

	protected PreparedStatement getDeleteStatement(int id, Connection con)

			throws SQLException {

		String query="DELETE FROM tasks WHERE job_id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setInt(1, id);

		return stmt;

	}

	@Override

	public List<TaskStored> getTasksOfJob(int id) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		TaskStored retTask = null;

		List<TaskStored> retList = null; 

		logger.debug("Accessing DB to get all Tasks of Job");

		try {

			con = getConnection();

			String query="SELECT status, success, started, ended, rule_id, record_identifier, record_url FROM tasks WHERE job_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, id);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<TaskStored>();

				while (rs.next()) {

					retTask = new TaskStored();

					retTask.setStatus(rs.getString(1));

					retTask.setSuccess(rs.getBoolean(2));

					retTask.setStarted(rs.getString(3));

					retTask.setEnded(rs.getString(4));

					retTask.setRuleId(rs.getInt(5));

					retTask.setRecordIdentifier(rs.getString(6));

					retTask.setRecordUrl(rs.getString(7));

					retTask.setJobId(id);

					retList.add(retTask);

				}				

			}

		} catch (Exception e) {

			logger.error("Accessing DB to get all Tasks of Job.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get all Tasks of Job.", e);

					throw new DaoException(e);

				}

			}

		}

		return retList;

	}

	@Override

	public TaskStored get(int id) {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	public List<String> getValidationErrors(int jobId, int ruleId) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<String> retList = null; 

		logger.debug("Accessing DB to get Validation Errors of JobId " + jobId + " and RuleId " + ruleId);

		try {

			con = getConnection();

			String query="SELECT record_identifier FROM tasks WHERE job_id=? AND rule_id=? AND success=? LIMIT 30";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, jobId);

			stmt.setInt(2, ruleId);

			stmt.setBoolean(3, false);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();

				while (rs.next()) {

//					if (!rs.getBoolean(1))

					retList.add(rs.getString(1));

				}				

			}

		} catch (Exception e) {

			logger.error("Accessing DB to get Validation Errors of a JobId and RuleId.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Validation Errors of a JobId and RuleId.", e);

					throw new DaoException(e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<String> getDistinctTasksOfJob(int jobId) throws DaoException {

		List<String> retList = null;

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to get Distinct Rule ids of Tasks");

		try {

			con = getConnection();

			String query="SELECT distinct rule_id from tasks where job_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, jobId);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();

				while (rs.next()) {

					retList.add(Integer.toString(rs.getInt(1)));

				}				

			}

		} catch (Exception e) {

			logger.error("Accessing DB to get Distinct Rule ids of Tasks.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Distinct Rule ids of Tasks.", e);

					throw new DaoException(e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<TaskStored> getFinishedTasks(int jobId, int ruleId) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		TaskStored retTask = null;

		List<TaskStored> retList = null; 

		logger.debug("Accessing DB to get Finished Tasks");

		try {

			con = getConnection();

			String query="SELECT success, record_identifier FROM tasks WHERE job_id=? AND rule_id=? AND status=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, jobId);

			stmt.setInt(2, ruleId);

			stmt.setString(3, "finished");

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<TaskStored>();

				while (rs.next()) {

					retTask = new TaskStored();

					retTask.setSuccess(rs.getBoolean(1));

					retTask.setRecordIdentifier(rs.getString(2));

					retList.add(retTask);

				}				

			}

		} catch (Exception e) {

			logger.error("Accessing DB to get Finished Tasks.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Finished Tasks.", e);

					throw new DaoException(e);

				}

			}

		}

		return retList;

	}

	@Override

	public void saveTasksBatch(List<TaskStored> tasks, Map<String,List<String>> groupByMap) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null, stmt1 = null;

		logger.debug("Accessing DB to save batch of tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";stmt = con.prepareStatement(query);

			stmt = con.prepareStatement(query);

			for (TaskStored t : tasks ) {

				stmt.setString(1, t.getStatus());

				stmt.setBoolean(2, t.getSuccess());

				stmt.setString(3, t.getStarted());

				stmt.setString(4, t.getEnded());

				stmt.setInt(5, t.getJobId());

				stmt.setInt(6, t.getRuleId());

				stmt.setString(7, t.getRecordIdentifier());

				stmt.setString(8, t.getRecordUrl());	

				stmt.addBatch();

		    }

		    stmt.executeBatch();

		    logger.debug("Tasks inserted: "+tasks.size());

		    if (!groupByMap.isEmpty()) {

		    	logger.debug("Inserting record's groupBy values..");

		    	for (Map.Entry<String, List<String>> entry : groupByMap.entrySet()) {

			    	query="INSERT INTO record_groupby(record_id, groupby, job_id) VALUES(?,?,?)";

			    	stmt1 = con.prepareStatement(query);

			    	for (String value :entry.getValue()) {

			    		stmt1.setString(1, entry.getKey());

			    		stmt1.setString(2, value);

			    		stmt1.setInt(3, tasks.get(0).getJobId());		

			    		stmt1.addBatch();

			    	}

		    	}

		    	stmt1.executeBatch();

//		    	logger.debug("groupBy values inserted: "+groupBy_values.size());		    	

		    }

		} catch (Exception e) {

			logger.error("Error Accessing DB to save batch of tasks.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks.", e);

					throw new DaoException(e);

				}

			}

			if (stmt1 != null) {

				try {

					stmt1.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks.", e);

					throw new DaoException(e);

				}

			}			

		}

	}

	@Override

	public void saveTasks(List<TaskStored> tasks, List<String> groupBy_values) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null, stmt1 = null;

		logger.debug("Accessing DB to save batch of tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";stmt = con.prepareStatement(query);

			stmt = con.prepareStatement(query);

			for (TaskStored t : tasks ) {

				stmt.setString(1, t.getStatus());

				stmt.setBoolean(2, t.getSuccess());

				stmt.setString(3, t.getStarted());

				stmt.setString(4, t.getEnded());

				stmt.setInt(5, t.getJobId());

				stmt.setInt(6, t.getRuleId());

				stmt.setString(7, t.getRecordIdentifier());

				stmt.setString(8, t.getRecordUrl());	

				stmt.addBatch();

		    }

		    stmt.executeBatch();

		    logger.debug("Tasks inserted: "+tasks.size());

		    if (groupBy_values != null) {

		    	logger.debug("Inserting record's groupBy values..");

		    	query="INSERT INTO record_groupby(record_id, groupby, job_id) VALUES(?,?,?)";

		    	stmt1 = con.prepareStatement(query);

		    	for (String value : groupBy_values) {

		    		stmt1.setString(1, tasks.get(0).getRecordIdentifier());

		    		stmt1.setString(2, value);

		    		stmt1.setInt(3, tasks.get(0).getJobId());		

		    		stmt1.addBatch();

		    	}

		    	stmt1.executeBatch();

		    	logger.debug("groupBy values inserted: "+groupBy_values.size());		    	

		    }

		} catch (Exception e) {

			logger.error("Error Accessing DB to save batch of tasks.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks.", e);

					throw new DaoException(e);

				}

			}

			if (stmt1 != null) {

				try {

					stmt1.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of tasks.", e);

				}

			}			

		}

	}

	@Override

	public void saveTasks(Map<Integer, RuleStatus> scoreMapPerRule) throws DaoException{

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to save batch of failed tasks");

		try {

			con = getConnection();

			String query="INSERT INTO tasks(status, success, started, ended, job_id, rule_id, record_identifier, record_url) VALUES(?,?,?,?,?,?,?,?)";

			stmt = con.prepareStatement(query);

			for (Entry<Integer, RuleStatus> entry : scoreMapPerRule.entrySet()) {

				for (TaskStored t : entry.getValue().getFailedTasks() ) {

					stmt.setString(1, t.getStatus());

					stmt.setBoolean(2, t.getSuccess());

					stmt.setString(3, t.getStarted());

					stmt.setString(4, t.getEnded());

					stmt.setInt(5, t.getJobId());

					stmt.setInt(6, t.getRuleId());

					stmt.setString(7, t.getRecordIdentifier());

					stmt.setString(8, t.getRecordUrl());	

					stmt.addBatch();

				}

			}

		    int result = stmt.executeBatch().length;

		    logger.debug("Tasks inserted: "+ result);

		} catch (Exception e) {

			logger.error("Error Accessing DB to save batch of failed tasks", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to save batch of failed tasks.", e);

					throw new DaoException(e);

				}

			}

		}

	}

	@Override

	protected int getLastId() throws DaoException {

		return 1;

//		ResultSet rs = null;

//		Connection con = null;

//		PreparedStatement stmt = null;

//		int retId = -1;

//		logger.debug("Accessing DB to get Task's next available id");

//		try {

//			con = getConnection();

//			String query="SELECT currval(pg_get_serial_sequence(?,?)) FROM tasks";

//			stmt = con.prepareStatement(query);

//			stmt.setString(1, "tasks");

//			stmt.setString(2, "rule_id");

//			

//			rs = stmt.executeQuery();

//			if (rs!=null){

//				rs.next();

//				retId=rs.getInt(1);

//			}

//

//

//		} catch (SQLException e) {

//			logger.error("Error while accessing DB to get Task's next available id.", e);

//		} finally {

//			if (stmt != null) {

//				try {

//					stmt.close();

//				} catch (SQLException e) {

//					logger.error("Error while accessing DB to get Task's next available id.", e);

//				}

//			}

//		}

//		return retId;

	}

	@Override

	public void cleanTasks(int jobId) throws DaoException{

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to delete unneeded tasks");

		try {

			con = getConnection();

			String query="DELETE FROM tasks WHERE job_id = ? AND success = ?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, jobId);

			stmt.setBoolean(2, true);

			stmt.executeUpdate();

			stmt.close();

		} catch (Exception e) {

			logger.error("Error while Accessing DB to delete unneeded tasks.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while Accessing DB to delete unneeded tasks.", e);

					throw new DaoException(e);

				}

			}

		}

	}

}

package eu.dnetlib.validator.commons.dao;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.apache.log4j.Logger;

import org.springframework.jdbc.datasource.DataSourceUtils;

public abstract class AbstractDAO<T> implements DAO<T> {

	protected DataSource datasource = null;

	protected abstract PreparedStatement getUpdateStatement(T t,Connection con) throws SQLException;

	protected abstract PreparedStatement getInsertStatement(T t,Connection con) throws SQLException;

	protected abstract PreparedStatement getDeleteStatement(int id,Connection con) throws SQLException;

	protected abstract int getLastId() throws SQLException, DaoException;

	protected static Logger logger = Logger.getLogger(AbstractDAO.class);

	@Override

	public Integer save(T t) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		Integer retId = -1;

		logger.debug("Accessing DB to save/update ");

		try {

			con = getConnection();

			stmt = getUpdateStatement(t,con);

			if (stmt.executeUpdate() == 0) {

				stmt.close();

				stmt = getInsertStatement(t,con);

				stmt.executeUpdate();

				retId=this.getLastId();

			}

		} catch (SQLException e) {

			logger.error("Error while accessing DB to save/update: ", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to save/update: ", e);

					throw new DaoException(e);

				}

			}

		}

		return retId;

	}

	@Override

	public String delete(int id) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to delete ");

		try {

			con = getConnection();

			stmt = getDeleteStatement(id,con);

			if (stmt.executeUpdate() == 0) {

				stmt.close();

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to delete: ", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (Exception e) {

					logger.error("Error while accessing DB to delete: ", e);

					throw new DaoException(e);

				}

			}

		}

		return null;

	}

	public Connection getConnection() throws DaoException {

		try {

			Connection conn = DataSourceUtils.getConnection(datasource);

			return conn;

		} catch (Exception e){

			throw new DaoException(e);

		}

	}

	public DataSource getDatasource() {

		return datasource;

	}

	public void setDatasource(DataSource datasource) {

		this.datasource = datasource;

	}

}

package eu.dnetlib.validator.commons.dao.repositories;

/**

 * 

 * @author Nikon Gasparis

 *

 */

public class RepositoryStored {

	private String baseUrl;

	private String activationId;

	public String getBaseUrl() {

		return baseUrl;

	}

	public void setBaseUrl(String baseUrl) {

		this.baseUrl = baseUrl;

	}

	public String getActivationId() {

		return activationId;

	}

	public void setActivationId(String activationId) {

		this.activationId = activationId;

	}

}

package eu.dnetlib.validator.commons.dao.repositories;

import java.util.List;

import eu.dnetlib.validator.commons.dao.DAO;

import eu.dnetlib.validator.commons.dao.DaoException;

public interface RepositoriesDAO extends DAO<RepositoryStored> {

	public List<String> getBaseUrls() throws DaoException;

}

package eu.dnetlib.validator.commons.dao.repositories;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import eu.dnetlib.validator.commons.dao.AbstractDAO;

import eu.dnetlib.validator.commons.dao.DaoException;

public class RepositoriesDAOImpl extends AbstractDAO<RepositoryStored> implements RepositoriesDAO {

	@Override

	public List<String> getBaseUrls() throws DaoException{

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<String> retList = null;

		logger.debug("Accessing DB to get all activated Repositories Stored");

		try {

			con = getConnection();

			String query="SELECT base_url FROM repositories WHERE activation_id is null";

			stmt = con.prepareStatement(query);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<String>();				

				while (rs.next()) {

					retList.add(rs.getString(1));

				}				

			}

		} catch (Exception e) {

			logger.error("Error while accessing DB to get all activated Repositories Stored: .", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to get all activated Repositories Stored: .", e);

					throw new DaoException(e);

				}

			}

		}

		return retList;

	}

	@Override

	protected PreparedStatement getUpdateStatement(RepositoryStored t,

			Connection con) throws SQLException {

		String query="UPDATE repositories SET activation_id=? WHERE activation_id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, null);

		stmt.setString(2, t.getActivationId());

		return stmt;

	}

	@Override

	protected PreparedStatement getInsertStatement(RepositoryStored t,

			Connection con) throws SQLException {

		String query="INSERT INTO repositories(base_url,activation_id) VALUES(?,?)";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setString(1, t.getBaseUrl());

		stmt.setString(2, t.getBaseUrl());

		return stmt;

	}

	@Override

	protected PreparedStatement getDeleteStatement(int id, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	protected int getLastId() throws SQLException {

		// TODO Auto-generated method stub

		return 0;

	}

	@Override

	public RepositoryStored get(int id) {

		// TODO Auto-generated method stub

		return null;

	}

}

package eu.dnetlib.validator.commons.dao.rules;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.*;

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

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

import eu.dnetlib.validator.commons.dao.AbstractDAO;

import eu.dnetlib.validator.commons.dao.DaoException;

public class RulesDAOimpl extends AbstractDAO<Rule> implements RulesDAO {

	@Override

	public Integer save(Rule t) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		Integer retId = -1;

		logger.debug("Accessing DB to save/update Rule");

		try {

			logger.debug("Accessing DB to update Rule");

			con = getConnection();

			String query="UPDATE rules SET name=?, description=?, type=?, mandatory=?, weight=?, provider_information=?, entity_type=?, for_cris=? WHERE id=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1, t.getName());

			stmt.setString(2, t.getDescription());

			stmt.setString(3, t.getType());

			stmt.setBoolean(4, t.isMandatory());

			stmt.setInt(5, t.getWeight());

			stmt.setString(6, t.getProvider_information());

			stmt.setString(7, t.getEntity_type());

			stmt.setBoolean(8, t.isFor_cris());

			stmt.setInt(9, t.getId());

			if (stmt.executeUpdate() == 0) {

				stmt.close();

				logger.debug("Accessing DB to save Rule with name:"+t.getName()+",desc:"+t.getDescription()+",type:"+t.getType()+",mand:"+t.isMandatory()+",weight:"+t.getWeight()+",pr_inf:"+t.getProvider_information()+",jb_tp:"+t.getJob_type());

				query="INSERT INTO rules(name, description, type, mandatory, weight, provider_information, job_type, entity_type, for_cris) VALUES(?,?,?,?,?,?,?,?,?)";

				stmt = con.prepareStatement(query);

				stmt.setString(1, t.getName());

				stmt.setString(2, t.getDescription());

				stmt.setString(3, t.getType());

				stmt.setBoolean(4, t.isMandatory());

				stmt.setInt(5, t.getWeight());

				stmt.setString(6, t.getProvider_information());

				stmt.setString(7, t.getJob_type());

				stmt.setString(8, t.getEntity_type());

				stmt.setBoolean(9, t.isFor_cris());

				stmt.executeUpdate();

				retId = this.getLastId();

			} else {

				logger.debug("Accessing DB to update Rule-done");

				retId=t.getId();

			}

			stmt.close();

			logger.debug("Accessing DB to delete Rule properties");

			query="DELETE FROM rule_properties " + " WHERE rule_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, retId);		

			if (stmt.executeUpdate() == 0) {

				stmt.close();

			}			

			logger.debug("Accessing DB to insert Rule properties");

			query="INSERT INTO rule_properties(rule_id, property_name, property_value) VALUES(?,?,?)";

		    stmt = con.prepareStatement(query);

			CustomProperties pros = t.getConfiguration();

		    for (Map.Entry<String, String> prop : pros.getProperties().entrySet()) {

			    String key = prop.getKey();

			    logger.debug("Accessing DB to add property:"+key+"-"+pros.getProperty(key));

				stmt.setInt(1, retId);

				stmt.setString(2, key);

				stmt.setString(3, pros.getProperty(key));

				stmt.addBatch();

		    }

		    stmt.executeBatch();

		    logger.debug("Rule + Properties inserted/updated");

		} catch (Exception e) {

			logger.error("Error accessing DB to get save/update Rule.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to get save/update Rule.", e);

					throw new DaoException(e);

				}

			}

		}

		return retId;

	}

	@Override

	public String delete(int id) throws DaoException {

		Connection con = null;

		PreparedStatement stmt = null;

		logger.debug("Accessing DB to delete Rule");

		try {

			con = getConnection();

			String query="DELETE FROM rules " + " WHERE id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, id);			

			if (stmt.executeUpdate() == 0) {

				stmt.close();

			}

			query="DELETE FROM rule_properties " + " WHERE rule_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, id);		

			if (stmt.executeUpdate() == 0) {

				stmt.close();

			}			

		} catch (Exception e) {

			logger.error("Error accessing DB to delete Rule.", e);

			throw new DaoException(e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to delete Rule.", e);

					throw new DaoException(e);

				}

			}

		}

		return null;

	}

	@Override

	protected PreparedStatement getDeleteStatement(int id, Connection con)

			throws SQLException {

		String query="DELETE FROM rules " + " WHERE id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setInt(1, id);	

		return stmt;

	}

	@Override

	public List<Rule> getAllRulesByJobType(String jobType) throws DaoException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		Rule retRule = null;

		List<Rule> retList = null;

		logger.debug("Accessing DB to get All Rules by jobType");

		try {

			con = getConnection();

			String query="SELECT * FROM rules WHERE job_type=? ORDER BY name";

			stmt = con.prepareStatement(query);

			stmt.setString(1, jobType);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<Rule>();				

				while (rs.next()) {

					retRule = new Rule();