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;

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;

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

	@Override

	public Integer save(T t) {

		Connection con = null;

		PreparedStatement stmt = null;

		Integer retId = -1;

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

		try {

			con = getConnection();

//			stmt = con.prepareStatement(getUpdateStatement(t));

			stmt = getUpdateStatement(t,con);

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

				stmt.close();

				stmt = getInsertStatement(t,con);

				stmt.executeUpdate();

//				con.commit();

				retId=this.getLastId();

			}

//			retId=this.getLastId();

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retId;

	}

	@Override

	public String delete(int id) {

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

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return null;

	}

	public Connection getConnection() throws SQLException {

		Connection conn = DataSourceUtils.getConnection(datasource);

		return conn;

	}

	public DataSource getDatasource() {

		return datasource;

	}

	public void setDatasource(DataSource datasource) {

		this.datasource = datasource;

	}

}

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

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

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

public class RepositoriesDAOImpl extends AbstractDAO<RepositoryStored> implements RepositoriesStoredDAO {

	@Override

	public List<String> getBaseUrls() {

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

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error while accessing DB to get all activated Repositories Stored: .", 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.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 eu.dnetlib.validator.commons.dao.DAO;

import java.util.List;

public interface RepositoriesStoredDAO extends DAO<RepositoryStored> {

	public List<String> getBaseUrls();

}

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

import java.util.List;

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

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

public interface RulesDAO extends DAO<Rule> {

	public List<Rule> getAllRulesByJobTypeEntityType(String jobType, String entityType);

	public List<Rule> getAllRulesByJobType(String jobType);

	public List<Rule> getAllRules();

}

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.ArrayList;

import java.util.Enumeration;

import java.util.List;

import java.util.Properties;

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

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

public class RulesDAOimpl extends AbstractDAO<Rule> implements RulesDAO{

	@Override

	public Integer save(Rule t) {

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

			Properties pros = t.getConfiguration();

		    Enumeration<?> e = pros.propertyNames();

		    while (e.hasMoreElements()) {

			    String key = (String) e.nextElement();

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

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retId;

	}

	@Override

	public String delete(int id) {

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

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to delete Rule.", 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) {

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

					retRule.setName(rs.getString("name"));

					retRule.setDescription(rs.getString("description"));

					retRule.setType(rs.getString("type"));

					retRule.setMandatory(rs.getBoolean("mandatory"));

					retRule.setWeight(rs.getInt("weight"));

					retRule.setProvider_information(rs.getString("provider_information"));

					retRule.setId(rs.getInt("id"));

					retRule.setEntity_type(rs.getString("entity_type"));

					retRule.setFor_cris(rs.getBoolean("for_cris"));

					retRule.setJob_type(rs.getString("job_type"));

					retRule.setConfiguration(this.getProperties(rs.getInt("id")));

					retList.add(retRule);

				}				

			}

		} catch (SQLException e) {

			logger.error("Error accessing DB to get All Rules by jobType.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to get All Rules by jobType.", e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<Rule> getAllRulesByJobTypeEntityType(String jobType, String entityType) {

		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=? AND entity_type=? ORDER BY name";

			stmt = con.prepareStatement(query);

			stmt.setString(1, jobType);

			stmt.setString(2, entityType);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<Rule>();				

				while (rs.next()) {

					retRule = new Rule();

					retRule.setName(rs.getString("name"));

					retRule.setDescription(rs.getString("description"));

					retRule.setType(rs.getString("type"));

					retRule.setMandatory(rs.getBoolean("mandatory"));

					retRule.setWeight(rs.getInt("weight"));

					retRule.setProvider_information(rs.getString("provider_information"));

					retRule.setId(rs.getInt("id"));

					retRule.setEntity_type(rs.getString("entity_type"));

					retRule.setFor_cris(rs.getBoolean("for_cris"));

					retRule.setJob_type(rs.getString("job_type"));

					retRule.setConfiguration(this.getProperties(rs.getInt("id")));

					retList.add(retRule);

				}				

			}

		} catch (SQLException e) {

			logger.error("Error accessing DB to get All Rules by jobType.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to get All Rules by jobType.", e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<Rule> getAllRules() {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<Rule> retList = null;

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

		try {

			con = getConnection();

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

			stmt = con.prepareStatement(query);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<Rule>();				

				while (rs.next()) {

					Rule retRule = new Rule();

					retRule.setName(rs.getString("name"));

					retRule.setDescription(rs.getString("description"));

					retRule.setType(rs.getString("type"));

					retRule.setMandatory(rs.getBoolean("mandatory"));

					retRule.setWeight(rs.getInt("weight"));

					retRule.setProvider_information(rs.getString("provider_information"));

					retRule.setId(rs.getInt("id"));

					retRule.setEntity_type(rs.getString("entity_type"));

					retRule.setFor_cris(rs.getBoolean("for_cris"));

					retRule.setJob_type(rs.getString("job_type"));

					retRule.setConfiguration(this.getProperties(rs.getInt("id")));

					retList.add(retRule);

				}				

			}

			logger.debug("rules: " + retList.size());

		} catch (SQLException e) {

			logger.error("Error accessing DB to get All Rule-pairs.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to get All Rule-pairs.", e);

				}

			}

		}

		return retList;

	}

	public Properties getProperties(int ruleId) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		Properties pros = null;

//		logger.debug("Accessing DB to get Rule Properties");

		try {

			con = getConnection();

			String query="SELECT property_name, property_value FROM rule_properties WHERE rule_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, ruleId);

			rs = stmt.executeQuery();

			if (rs!=null){

				pros = new Properties();

				while (rs.next()) {

					pros.setProperty(rs.getString(1), rs.getString(2));

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get Rule Properties.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get Rule Properties.", e);

				}

			}

		}

		return pros;

	}

	@Override

	public Rule get(int id) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		Rule retRule = null;

//		logger.debug("Accessing DB to get Rule with id: "+id);

		try {

			con = getConnection();

			String query="SELECT name, description, type, mandatory, weight, provider_information, job_type, entity_type, for_cris FROM rules WHERE id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, id);

			rs = stmt.executeQuery();

			if (rs!=null){

				if (rs.next()) {

					retRule = new Rule();

					retRule.setName(rs.getString(1));

					retRule.setDescription(rs.getString(2));

					retRule.setType(rs.getString(3));

					retRule.setMandatory(rs.getBoolean(4));

					retRule.setWeight(rs.getInt(5));

					retRule.setProvider_information(rs.getString(6));

					retRule.setJob_type(rs.getString(7));

					retRule.setEntity_type(rs.getString(8));

					retRule.setFor_cris(rs.getBoolean(9));

					retRule.setId(id);

					retRule.setConfiguration(this.getProperties(id));

				}				

			}

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

//		logger.debug("Accessing DB to get Rule with name: "+retRule.getName());

		return retRule;

	}

	@Override

	protected int getLastId() throws SQLException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		int retId = -1;

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

		try {

			con = getConnection();

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

			stmt = con.prepareStatement(query);

			stmt.setString(1, "rules");

			stmt.setString(2, "id");

			rs = stmt.executeQuery();

			if (rs!=null){

				rs.next();

				retId=rs.getInt(1);

			}

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retId;

	}

	@Override

	protected PreparedStatement getUpdateStatement(Rule t, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	protected PreparedStatement getInsertStatement(Rule t, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

}

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

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

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

import java.util.List;

/**

 * 

 * @author nickonas

 *

 */

public interface RulesetsDAO extends DAO<RuleSet> {

	/**

	 * 

	 * @return

	 */

	public List<RuleSet> getRuleSets();

}

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

import eu.dnetlib.validator.commons.dao.tasks.TaskStored;

import java.util.ArrayList;

import java.util.List;

public class RuleStatus {

	public int total = 0;

	public int success = 0;

	private int weight = 0;

	private List<TaskStored> failedTasks = new ArrayList<TaskStored>();

	boolean mandatory;

	public RuleStatus() {

		super();

	}

	public boolean isMandatory() {

		return mandatory;

	}

	public void setMandatory(boolean mandatory) {

		this.mandatory = mandatory;

	}

	public int getTotal() {

		return total;

	}

	public void setTotal(int total) {

		this.total = total;

	}

	public int getSuccess() {

		return success;

	}

	public void setSuccess(int success) {

		this.success = success;

	}

	public List<TaskStored> getFailedTasks() {

		return failedTasks;

	}

	public void setFailedTasks(List<TaskStored> failedTasks) {

		this.failedTasks = failedTasks;

	}

	public int getWeight() {

		return weight;

	}

	public void setWeight(int weight) {

		this.weight = weight;

	}

}

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

import java.sql.Array;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

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

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

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

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

public class RulesetsDAOimpl extends AbstractDAO<RuleSet> implements RulesetsDAO{

	@Override

	public Integer save(RuleSet t) {

		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 rulesets SET name=?, description=?, guidelines_acronym = ?, visibility = ?, short_name=? WHERE id=?";

			stmt = con.prepareStatement(query);

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

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

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

			String[] data = t.getVisibility().toArray(new String[t.getVisibility().size()]);

			stmt.setArray(4, con.createArrayOf("text", data));

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

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

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

				stmt.close();

				logger.debug("Accessing DB to save RuleSet with name: "+t.getName());

				query="INSERT INTO rulesets(name,description,guidelines_acronym,visibility,short_name) VALUES(?,?,?,?,?)";

				stmt = con.prepareStatement(query);

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

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

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

				data = t.getVisibility().toArray(new String[t.getVisibility().size()]);

				stmt.setArray(4, con.createArrayOf("text", data));

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

				stmt.executeUpdate();

				retId = this.getLastId();

			} else {

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

				retId=t.getId();

			}

			stmt.close();

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

			query="DELETE FROM ruleset_has_rules " + " WHERE ruleset_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, retId);		

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

				stmt.close();

			}			

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

		    query="INSERT INTO ruleset_has_rules(ruleset_id, rule_id) VALUES (?,?)";

			stmt= con.prepareStatement(query);

			for (int id : t.getContentRulesIds()) {

				stmt.setInt(1,retId);

				stmt.setInt(2,id);

				stmt.addBatch();

			}

			for (int id : t.getUsageRulesIds()) {

				stmt.setInt(1,retId);

				stmt.setInt(2,id);

				stmt.addBatch();

			}

			stmt.executeBatch();

		    logger.debug("Ruleset_has_rules values inserted/updated");

		} catch (SQLException e) {

			logger.error("Error accessing DB to save ruleset.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to save ruleset.", e);

				}

			}

		}

		return retId;

	}

	@Override

	public RuleSet get(int id) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		RuleSet retSet = null;

		logger.debug("Accessing DB to get RuleSet with id: " + id);

		try {

			con = getConnection();

			String query="SELECT name, description, guidelines_acronym, visibility, short_name FROM rulesets WHERE id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, id);

			rs = stmt.executeQuery();

			if (rs!=null){

				retSet = new RuleSet();

				while (rs.next()) {

					retSet.setName(rs.getString(1));

					retSet.setDescription(rs.getString(2));

					retSet.setGuidelinesAcronym(rs.getString(3));

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

					Array tt = rs.getArray("visibility");

					if (tt != null) {

						String[] ent = (String[])tt.getArray();

						visibility.addAll(Arrays.asList(ent));

					}

					retSet.setVisibility(visibility);

					retSet.setShortName(rs.getString(5));

					retSet.setId(id);

					List <Rule> rules = this.getRulesOfRuleset(id);

					List <Rule> contentRules = new ArrayList<Rule>();

					List <Rule> usageRules = new ArrayList<Rule>();

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

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

					for (Rule rule : rules) {

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

							contentRules.add(rule);

							contentRulesIds.add(rule.getId());

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

							usageRules.add(rule);

							usageRulesIds.add(rule.getId());

						}

					}

					retSet.setContentRules(contentRules);

					retSet.setUsageRules(usageRules);

					retSet.setContentRulesIds(contentRulesIds);

					retSet.setUsageRulesIds(usageRulesIds);

				}				

			}

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retSet;

	}

	public List<RuleSet> updateRuleSetHasRules() {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null, stmt1 = null;;

		List<RuleSet> retList = new ArrayList<RuleSet>();

		RuleSet retSet = null;

		logger.debug("Accessing DB to get all RuleSets");

		try {

			con = getConnection();

			String query="SELECT name, description, guidelines_acronym, visibility, content_rules, usage_rules, id, short_name FROM rulesets";

			stmt = con.prepareStatement(query);

			rs = stmt.executeQuery();

			if (rs!=null){

				while (rs.next()) {

					retSet = new RuleSet();

					retSet.setName(rs.getString(1));

					retSet.setDescription(rs.getString(2));

					retSet.setGuidelinesAcronym(rs.getString(3));

					retSet.setVisibility(Utilities.convertStringToList(rs.getString(4)));

					retSet.setId(rs.getInt(7));

					retSet.setShortName(rs.getString(8));

					retList.add(retSet);

					String query1="INSERT INTO ruleset_has_rules(ruleset_id, rule_id) values (?,?)";

					stmt1 = con.prepareStatement(query1);

					for (String id : Utilities.convertStringToList(rs.getString(5))) {

						stmt1.setInt(1,retSet.getId());

						stmt1.setInt(2,Integer.parseInt(id));

						stmt1.addBatch();

					}

					for (String id : Utilities.convertStringToList(rs.getString(6))) {

						stmt1.setInt(1,retSet.getId());

						stmt1.setInt(2,Integer.parseInt(id));

						stmt1.addBatch();

					}

					stmt1.executeBatch();

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get all RuleSets.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get all RuleSets.", e);

				}

			}

		}

		return retList;

	}

	@Override

	public List<RuleSet> getRuleSets() {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		List<RuleSet> retList = new ArrayList<RuleSet>();

		RuleSet retSet = null;

		logger.debug("Accessing DB to get all RuleSets");

		try {

			con = getConnection();

			String query="SELECT name, description, guidelines_acronym, visibility, id, short_name FROM rulesets ORDER BY id";

			stmt = con.prepareStatement(query);

			rs = stmt.executeQuery();

			if (rs!=null){

				while (rs.next()) {

					retSet = new RuleSet();

					retSet.setName(rs.getString(1));

					retSet.setDescription(rs.getString(2));

					retSet.setGuidelinesAcronym(rs.getString(3));

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

					Array tt = rs.getArray("visibility");

					if (tt != null) {

						String[] ent = (String[])tt.getArray();

						visibility.addAll(Arrays.asList(ent));

					}

					retSet.setVisibility(visibility);

					retSet.setId(rs.getInt(5));

					retSet.setShortName(rs.getString(6));

					List <Rule> rules = this.getRulesOfRuleset(retSet.getId());

					List <Rule> contentRules = new ArrayList<Rule>();

					List <Rule> usageRules = new ArrayList<Rule>();

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

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

					for (Rule rule : rules) {

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

							contentRules.add(rule);

							contentRulesIds.add(rule.getId());

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

							usageRules.add(rule);

							usageRulesIds.add(rule.getId());

						}

					}

					retSet.setContentRules(contentRules);

					retSet.setUsageRules(usageRules);

					retSet.setContentRulesIds(contentRulesIds);

					retSet.setUsageRulesIds(usageRulesIds);

					retList.add(retSet);

				}				

			}

		} catch (SQLException e) {

			logger.error("Accessing DB to get all RuleSets.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Accessing DB to get all RuleSets.", e);

				}

			}

		}

		return retList;

	}

	public List<Rule> getRulesOfRuleset(int ruleSetId) {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		Rule retRule = null;

		List<Rule> retList = null;

		logger.debug("Accessing DB to get All Rules of ruleset");

		try {

			con = getConnection();

			String query="SELECT * FROM rules r, ruleset_has_rules rhs WHERE rhs.rule_id = r.id AND rhs.ruleset_id=?";

			stmt = con.prepareStatement(query);

			stmt.setInt(1, ruleSetId);

			rs = stmt.executeQuery();

			if (rs!=null){

				retList = new ArrayList<Rule>();				

				while (rs.next()) {

					retRule = new Rule();

					retRule.setName(rs.getString("name"));

					retRule.setDescription(rs.getString("description"));

					retRule.setType(rs.getString("type"));

					retRule.setMandatory(rs.getBoolean("mandatory"));

					retRule.setWeight(rs.getInt("weight"));

					retRule.setProvider_information(rs.getString("provider_information"));

					retRule.setId(rs.getInt("id"));

					retRule.setEntity_type(rs.getString("entity_type"));

					retRule.setFor_cris(rs.getBoolean("for_cris"));

					retRule.setJob_type(rs.getString("job_type"));

//					retRule.setConfiguration(this.getProperties(rs.getInt("id")));

					retList.add(retRule);

				}				

			}

			logger.debug("rules: " + retList.size());

		} catch (SQLException e) {

			logger.error("Error accessing DB to get All Rules by jobType.", e);

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

					logger.error("Error accessing DB to get All Rules by jobType.", e);

				}

			}

		}

		return retList;

	}

	@Override

	protected PreparedStatement getDeleteStatement(int id, Connection con)

			throws SQLException {

		String query="DELETE FROM rulesets WHERE id=?";

		PreparedStatement stmt = con.prepareStatement(query);

		stmt.setInt(1,id);

		return stmt;

	}

	@Override

	protected int getLastId() throws SQLException {

		ResultSet rs = null;

		Connection con = null;

		PreparedStatement stmt = null;

		int retId = -1;

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

		try {

			con = getConnection();

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

			stmt = con.prepareStatement(query);

			stmt.setString(1, "rulesets");

			stmt.setString(2, "id");

			rs = stmt.executeQuery();

			if (rs!=null){

				rs.next();

				retId=rs.getInt(1);

			}

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retId;

	}

	@Override

	protected PreparedStatement getUpdateStatement(RuleSet t, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

	@Override

	protected PreparedStatement getInsertStatement(RuleSet t, Connection con)

			throws SQLException {

		// TODO Auto-generated method stub

		return null;

	}

}

package eu.dnetlib.validator.commons.dao;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

public class Utilities {

	public static Set<Integer> convertArrayToSet (String[] array){

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

		for (String id : array) {

			ret.add(Integer.parseInt(id));

		}

		return ret;

	}

	public static List<String> convertArrayToList (String[] array){

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

		for (String id : array) {

			ret.add(id);

		}

		return ret;

	}

	public static Set<Integer> convertListToSet (List<String> list){

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

		for (String id : list) {

			ret.add(Integer.parseInt(id));

		}

		return ret;

	}	

	public static String convertListToString(List<String> ruleIds) {

		String rules = "";

		for (int i = 0; i < ruleIds.size() - 1; i++)

			rules += ruleIds.get(i) + ",";

		rules += ruleIds.get(ruleIds.size() - 1);

		return rules;

	}

	public static List<String> convertStringToList(String rules) {

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

		String[] arrRules = rules.split(",");

		for (String sRule : arrRules) {

			ruleIds.add(sRule.trim());

		}

		return ruleIds;

	}

	public static String convertSetToString(Set<Integer> ruleIds) {

		String rules = "";

		for (int i  : ruleIds)

			rules += i + ",";

		rules = rules.substring(0,rules.length()-1);

		return rules;

	}

	public static Set<Integer> convertStringToSet(String rules) {

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

		String[] arrRules = rules.split(",");

		for (String sRule : arrRules) {

			ruleIds.add(Integer.parseInt(sRule.trim()));

		}

		return ruleIds;

	}

	public static String formatTime(long mills) {

		long secs = mills / 1000;

		long mins = secs / 60;

		if (mins == 0)

			return secs + " secs";

		secs = secs % 60;

		long hours = mins / 60;

		if (hours == 0)

			return mins + " mins " + secs + " secs";

		mins = mins % 60;

		return hours + " hours " + mins + " mins " + secs + " secs";

	}	

}

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

import java.util.List;

public class Entry {

	private String name, description;

	private String successes;

	private int weight;

	private List<String> errors;

	private int ruleId;

	private boolean hasErrors, mandatory;

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getDescription() {

		return description;

	}

	public void setDescription(String description) {

		this.description = description;

	}

	public String getSuccesses() {

		return successes;

	}

	public void setSuccesses(String successes) {

		this.successes = successes;

	}

	public List<String> getErrors() {

		return errors;

	}

	public void setErrors(List<String> errors) {

		this.errors = errors;

	}

	public void setRuleId(int ruleId) {

		this.ruleId = ruleId;

	}

	public int getRuleId() {

		return ruleId;

	}

	public void setHasErrors(boolean hasErrors) {

		this.hasErrors = hasErrors;

	}

	public boolean isHasErrors() {

		return hasErrors;

	}

	public void setWeight(int weight) {

		this.weight = weight;

	}

	public int getWeight() {

		return weight;

	}

	public boolean isMandatory() {

		return mandatory;

	}

	public void setMandatory(boolean mandatory) {

		this.mandatory = mandatory;

	}

}

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

import java.util.List;

import java.util.Map;

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

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

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

public interface JobsDAO extends DAO<StoredJob> {

	public int deleteUncompletedJobs();

	public int deleteOld(String date, String period, String jobType);

	public int setJobFinished(int jobId,

			Map<String, Map<Integer, RuleStatus>> scoreMapPerGroupBy,

			String error, Boolean failed, int objsValidated, String validationType);

	public void setTotalJobFinished(int jobId, String error, Boolean failed);

	public void setStatus(int jobId, String status, int recordsTested, String validationType);

	public List<StoredJob> getUncompletedJobs();

	public List<StoredJob> getJobs(String userName, String jobType, Integer offset, Integer limit, String dateFrom, String dateTo);

	public int getJobsTotalNumber(String userName, String jobType);

	public StoredJob getJobSummary(int jobId, String groupby);

	public void importOldJobs();

	/*

	public Map<String, List<StoredJob>> getJobsOfUserSplitted(String userName);

	public boolean getJobError(int jobId);

	public void deleteOldCompatibilityTestsOnly(String date);

	public void deleteJobForRegistration(String activationId);

	public void deleteSemiCompletedRegistrationJobs(String activationId);

	public void deleteJobsForRegistration();

	*/

}

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

import java.sql.Array;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

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

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

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

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

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

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

public class JobsDAOImpl extends AbstractDAO<StoredJob> implements JobsDAO{

	@Override

	public Integer save(StoredJob job) {

		Connection con = null;

		PreparedStatement stmt = null;

		Integer retId = -1;

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

		try {

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

			Calendar cal = Calendar.getInstance();

			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			con = getConnection();

			logger.debug("getting submittedjob updateStatement");

			String query="UPDATE jobs SET validation_type=?, started=to_timestamp(?, 'YYYY-MM-DD HH24:MI:SS'), guidelines=?, content_job_status=?, repo=?, duration=? WHERE id=?";

			stmt = con.prepareStatement(query);

			stmt.setString(1, job.getValidationType());

			stmt.setString(2, sdf.format(cal.getTime()));

			stmt.setString(3, job.getDesiredCompatibilityLevel());

			stmt.setString(4, job.getContentJobStatus());

			stmt.setString(5, job.getBaseUrl());

			stmt.setString(6, job.getDuration());

			stmt.setInt(7, job.getId());

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

				stmt.close();

				logger.debug("Accessing DB to save Job");

				query="INSERT INTO jobs(validation_type,started,guidelines,user_email,content_job_status, usage_job_status, repo, duration, rules, records, set, groupby_xpath, metadata_prefix, job_type) VALUES(?,to_timestamp(?, 'YYYY-MM-DD HH24:MI:SS'),?,?,?,?,?,?,?,?,?,?,?,?)";

				stmt = con.prepareStatement(query);

				stmt.setString(1, job.getValidationType());

				stmt.setString(2, sdf.format(cal.getTime()));

//				stmt.setTimestamp(2, getCurrentTimeStamp());

				stmt.setString(3, job.getDesiredCompatibilityLevel());

				stmt.setString(4, job.getUserEmail());

				stmt.setString(5, job.getContentJobStatus());

				stmt.setString(6, job.getUsageJobStatus());

				stmt.setString(7, job.getBaseUrl());

				stmt.setString(8, job.getDuration());

				stmt.setString(9, Utilities.convertSetToString(job.getRules()));

				stmt.setString(10, Integer.toString(job.getRecords()));

				stmt.setString(11, job.getValidationSet());

				stmt.setString(12, job.getGroupByXpath());

				stmt.setString(13, job.getMetadataPrefix());

				stmt.setString(14, job.getJobType());

				stmt.executeUpdate();

				retId = this.getLastId();

			} else {

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

				retId=job.getId();

			}

			if (job.isRegistration()) {

				this.storeJobForRegistration(job, retId);

			}

			if (job.isCris()) {

				this.storeJobForCris(job, retId);

			}

			stmt.close();

		} catch (SQLException e) {

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

		} finally {

			if (stmt != null) {

				try {

					stmt.close();

				} catch (SQLException e) {

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

				}

			}

		}

		return retId;

	}

	@Override

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

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

		PreparedStatement stmt = con.prepareStatement(query);