D-Net

package eu.dnetlib.validator.service.impls.listeners;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.springframework.http.*;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import eu.dnetlib.api.data.DatasourceManagerService;

import eu.dnetlib.validator.commons.dao.jobs.JobsDAO;

import eu.dnetlib.validator.commons.email.Emailer;

import eu.dnetlib.validator.engine.execution.CompletedTask;

import eu.dnetlib.validator.engine.execution.JobListener;

import gr.uoa.di.driver.util.ServiceLocator;

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.util.MultiValueMap;

import org.springframework.web.client.RestTemplate;

public class RegistrationListener implements JobListener{

//	private String valBaseUrl = null;

	private String providerUrl = null;

	private JobsDAO jobsDao;

	private int jobId;

//	private String activationId;

	private String userMail;

//	private String officialName;

//	private String baseUrl;

	private String datasourceId;

	private String interfaceId;

//	private String interfaceIdOld;

//	private String validationSet;

//	private String desiredCompLevel;

//	private String repoType;

	private boolean updateExisting;

	private int totalJobs;

	private int jobsFinished = 0;

	private int score_content = 0, score_usage = 0;

	private static Logger logger = Logger.getLogger(RegistrationListener.class);

	public RegistrationListener() {

		logger.error("Creating new registration listener");

	}

	@Override

	@Transactional(propagation = Propagation.REQUIRED)

	public synchronized void finished(int jobId, Map<String, Object> jobContext) {

		try{

			jobsFinished++;

			if (jobContext.containsKey("score_content")) {

				score_content = (Integer) jobContext.get("score_content");

			} else if (jobContext.containsKey("score_usage")) {

				score_usage = (Integer) jobContext.get("score_usage");

			}

			if (jobsFinished == totalJobs) {

				logger.debug("all jobs for registration finished");

				jobsDao.setTotalJobFinished(jobId, null, false);

				logger.debug("id:"+jobId+ "c: " + score_content + " u:" + score_usage);

				this.jobSuccess((Integer) jobContext.get("jobSubmittedId"), score_content, score_usage);

			} else {

				logger.debug("not all jobs finished yet. Waiting "+ (totalJobs-jobsFinished) + " job(s) to finish" );

			}

		} catch (Exception e) {

			logger.error("Error while finalizing successfull registration job");

		}

	}

	@Override

	@Transactional(propagation = Propagation.REQUIRED)

	public synchronized void failed(int jobId, Map<String, Object> jobContext, Throwable t) {

		try{

			jobsDao.setTotalJobFinished(jobId, t.getMessage(), true);

			this.jobFailure((Integer) jobContext.get("jobSubmittedId"),t.getMessage());

		} catch (Exception e) {

			logger.error("Error while finalizing failed registration job");

		}

	}

	@Override

	public synchronized void currentResults(List<CompletedTask> tasks, int jobId,

											Object object, Map<String, Object> recordContext, Throwable t) {

		// We don't care about partial results.

	}

	@Override

	public synchronized void currentResults(List<CompletedTask> tasks, int jobId,

											Object object, Map<String, Object> recordContext) {

		// We don't care about partial results.

	}

	public synchronized void jobSuccess(int jobId, int score_content, int score_usage) {

		logger.info("Preregistration job "+jobId+" finished");

		this.score_content = score_content;

		this.score_usage = score_usage;

		this.jobId=jobId;

		this.success();

	}

	public synchronized void jobFailure(int jobId, String error) {

		logger.info("Pregistration job "+jobId+" failed with exception: "+error);

		this.jobId=jobId;

		this.error();

	}

	private void success() {

		try {

		    logger.debug("Sending results to provide @ " + providerUrl +"/validator/complete");

			HttpHeaders headers = new HttpHeaders();

			headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

			MultiValueMap<String, String> map= new LinkedMultiValueMap<String, String>();

			map.add("interfaceId", this.interfaceId);

			map.add("repoId",this.datasourceId);

			map.add("jobId",Integer.toString(this.jobId));

			map.add("issuerEmail",this.userMail);

			map.add("isUpdate",Boolean.toString(this.updateExisting));

			// isUsccess: the job finished succesfully, regardless of validation scores.

			map.add("isSuccess","true");

			map.add("scoreUsage", Integer.toString(score_usage));

			map.add("scoreContent",Integer.toString(score_content));

			HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<MultiValueMap<String, String>>(map, headers);

			RestTemplate restTemplate = new RestTemplate();

			ResponseEntity<String> response = restTemplate.postForEntity( providerUrl + "/validator/complete", request , String.class );

//			this.updateRepositoryInterfaceCompliance(officialName, datasourceId, interfaceId, desiredCompLevel, validationSet, baseUrl, interfaceIdOld);

		} catch (Exception e) {

			logger.error("", e);

		}

	}

	private void error() {

		try {

			logger.debug("Sending results to provide @ " + providerUrl + "/validator/complete");

			HttpHeaders headers = new HttpHeaders();

			headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

			MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();

			map.add("interfaceId", this.interfaceId);

			map.add("repoId", this.datasourceId);

			map.add("jobId", this.jobId + "");

			map.add("issuerEmail", this.userMail);

			map.add("isUpdate", this.updateExisting + "");

			// The job failed to complete. Validator error or Repository is completely dead and cannot be validated.

			map.add("isSuccess", "false");

			map.add("scoreUsage", score_usage + "");

			map.add("scoreContent", score_content + "");

			HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<MultiValueMap<String, String>>(map, headers);

			RestTemplate restTemplate = new RestTemplate();

			ResponseEntity<String> response = restTemplate.postForEntity(providerUrl + "/validator/complete", request, String.class);

//			this.updateRepositoryInterfaceCompliance(officialName, datasourceId, interfaceId, "notCompatible", validationSet, baseUrl, interfaceIdOld);

		} catch (Exception e) {

			logger.error("", e);

		}

	}

//	public boolean updateRepositoryInterfaceCompliance(String officialName,

//			String datasourceId, String interfaceId, String desiredCompliance, String set, String baseUrl, String oldId)

//					throws Exception {

//		boolean ret = true;

//		try {

//			if (desiredCompliance.equalsIgnoreCase("openaire2.0_data"))

//				desiredCompliance = "openaire2.0";

//			logger.debug("updating repository " + officialName + " compliance to : " + desiredCompliance);

//			if (oldId == null) {

//				dmService.getService().updateLevelOfCompliance(datasourceId, interfaceId, desiredCompliance);

//			}

//			else {

//				logger.debug("Checking if old interface should be updated");

//				if (!desiredCompliance.equalsIgnoreCase("UNKNOWN") && (!desiredCompliance.equalsIgnoreCase("notCompatible"))) {

//					logger.debug("updating old interface with new set/url");

//					dmService.getService().updateBaseUrl(datasourceId, oldId, baseUrl);

//					if(set.equalsIgnoreCase("none"))

//						dmService.getService().deleteAccessParamOrExtraField(datasourceId, oldId, "set");

//					else

//						dmService.getService().updateAccessParam(datasourceId, oldId, "set", set, false);

//					logger.debug("deleting new interface");

//					dmService.getService().deleteInterface(datasourceId, interfaceId);

//

//				}

//				logger.debug("updating repository " + officialName + " compliance to : " + desiredCompliance);

//			}

//			java.util.Date utilDate = new java.util.Date();

//			java.sql.Timestamp date = new java.sql.Timestamp(utilDate.getTime());

//

//			String updateQuery = "UPDATE datasources SET activationid = " + null + "," +

//					" dateofvalidation = '" + date + "'" +

//					" WHERE id = '" + datasourceId + "'";

//

//			if (dmService.getService().updateSQL(datasourceId, updateQuery, false))

//				logger.debug("updated successfully");

//			else

//				logger.error("error while updating: " + updateQuery);

//

//		} catch (Exception e) {

//			logger.error("error connecting to dms to set a repo interface as openaire compliant " + officialName, e);

//			ret = false;

//			throw e;

//		}

//		return ret;

//	}

//

	public String getProviderUrl() {

		return providerUrl;

	}

	public void setProviderUrl(String providerUrl) {

		this.providerUrl = providerUrl;

	}

	public JobsDAO getJobsDao() {

		return jobsDao;

	}

	public void setJobsDao(JobsDAO jobsDao) {

		this.jobsDao = jobsDao;

	}

	public int getJobId() {

		return jobId;

	}

	public void setJobId(int jobId) {

		this.jobId = jobId;

	}

	public String getUserMail() {

		return userMail;

	}

	public void setUserMail(String userMail) {

		this.userMail = userMail;

	}

	public String getDatasourceId() {

		return datasourceId;

	}

	public void setDatasourceId(String datasourceId) {

		this.datasourceId = datasourceId;

	}

	public String getInterfaceId() {

		return interfaceId;

	}

	public void setInterfaceId(String interfaceId) {

		this.interfaceId = interfaceId;

	}

	public boolean isUpdateExisting() {

		return updateExisting;

	}

	public void setUpdateExisting(boolean updateExisting) {

		this.updateExisting = updateExisting;

	}

	public int getTotalJobs() {

		return totalJobs;

	}

	public void setTotalJobs(int totalJobs) {

		this.totalJobs = totalJobs;

	}

}