D-Net

package gr.uoa.di.validatorweb.actions.registration.dnet;

import eu.dnetlib.domain.data.Repository;

import eu.dnetlib.domain.data.RepositoryInterface;

import eu.dnetlib.domain.enabling.Vocabulary;

import gr.uoa.di.driver.enabling.vocabulary.VocabularyLoader;

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

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

import gr.uoa.di.validatorweb.api.RepoExtAPI;

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

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

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.apache.struts2.interceptor.SessionAware;

import se.kb.oai.pmh.Identification;

import se.kb.oai.pmh.OaiPmhServer;

import com.opensymphony.xwork2.Action;

import com.unboundid.util.Base64;

public class RepoRegistration extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = -2912240396302341015L;

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

	private VocabularyLoader vocabularyLoader = null;

	private Map<String, Object> session;

	private List<String> adminEmails;

	private Repository repo;

	private List<RepositoryInterface> interfaces, interfacesToRegister = new ArrayList<RepositoryInterface>();;

	private PubFileInterface pubFileIface;

	private String customTypology;

	private String mode;

	private String id;

	public String aggregatorName;

	private boolean usingOpenDoar;

	private List<String> typologies;

	private List<String> countries;

	private List<Timezone> timezones;

	public String execute() {

		this.clearErrorsAndMessages();

		logger.debug("mode: " + mode + " usingOpenDoar:" + usingOpenDoar + " repoId " + repo.getId());

		String importResult = null;

		String activationId = UUID.randomUUID().toString();

		String repoType = "repository";

		if (mode.equalsIgnoreCase("opendoar"))

			repoType = "literature repository";

		else if (mode.equalsIgnoreCase("re3data"))

			repoType = "data repository";

		else if (mode.equalsIgnoreCase("journal"))

			repoType = "journal";

		else if (mode.equalsIgnoreCase("aggregator"))

			repoType = "aggregator";

		try{			

			repo.setCountryCode(getCountryCode(repo.getCountryName()));

			repo.setActivationId(activationId);

			repo.setRegisteredBy((String) session.get(Constants.loggedInField));

			repo.setInterfaces(interfaces);

			repo.setInterfaces(this.interfaces);

			if (this.isModeOpenAIRE()) {

				if (mode.equals("opendoar") || mode.equals("re3data")) {		

					repo.setProvenanceActionClass("sysimport:crosswalk:entityregistry");

					repo.setId(this.id);

					importResult = getRepoAPI().storeRepository(repo,mode,interfacesToRegister);				

				}

				if (mode.equals("journal")) {

					repo.setProvenanceActionClass("user:insert");

					repo.setCollectedFrom("infrastruct_::openaire");

					repo.setDatasourceClass("pubsrepository::journal");

					if(repo.getIssn() != null && repo.getIssn().length() == 0)

						repo.setIssn(Base64.encode(repo.getOfficialName()).substring(0,8));

					repo.setId("openaire____::issn" + repo.getIssn());

					repo.setNamespacePrefix("issn" + repo.getIssn());

					logger.debug("RegisteredBy: " + repo.getRegisteredBy());

					importResult = getRepoAPI().storeRepository(repo,"journal",interfacesToRegister);

				}

				else if (mode.equals("aggregator")) {

					repo.setProvenanceActionClass("user:insert");

					repo.setCollectedFrom("infrastruct_::openaire");

					repo.setDatasourceClass("aggregator::pubsrepository::unknown");

					repo.setId("openaire____::" + Base64.encode(repo.getOfficialName()));

					repo.setNamespacePrefix(repo.getOfficialName().toLowerCase().replace(" ", "_"));

					if (repo.getNamespacePrefix().length() > 12) {

						repo.setNamespacePrefix(repo.getNamespacePrefix().substring(0,12));

					} else { 

						while (repo.getNamespacePrefix().length() < 12)

							repo.setNamespacePrefix(repo.getNamespacePrefix().concat("_"));

					}

					importResult = getRepoAPI().storeRepository(repo,"aggregator",interfacesToRegister);

				}	

			}

			if (importResult != null)

				this.addActionMessage(importResult);

			if (pubFileIface != null && pubFileIface.getAllow()) {

				RepositoryInterface fileIface = new RepositoryInterface();

				fileIface.setBaseUrl("none");

				fileIface.setContentDescription("file::hybrid");

				fileIface.setCompliance("files");

				fileIface.setTypology("pubsrepository::unknown");

				fileIface.setRemovable(true);

				fileIface.setId("api_________::" + repo.getId() + "::" + "files");

				fileIface.getAccessParams().put("methodology", pubFileIface.getMethodology());

//				fileIface.getExtraFields().put("allow", "yes");

				if (pubFileIface.getMethodology().equals("files_from_api")) {

					fileIface.setAccessProtocol(pubFileIface.getProtocol());

					fileIface.getAccessParams().put("url", pubFileIface.getUrl());

					fileIface.getAccessParams().put("username", pubFileIface.getUsername());

					fileIface.getAccessParams().put("password", pubFileIface.getPassword());

					fileIface.getExtraFields().put("file_naming_convention", pubFileIface.getConvention());

				} else if (pubFileIface.getMethodology().equals("files_from_metadata")) {

					fileIface.setAccessProtocol("files_from_metadata");

					fileIface.getAccessParams().put("xpath",pubFileIface.getXpath());

				}

//				

				logger.debug("source: " + pubFileIface.getMethodology());

				logger.debug("protocol: " + pubFileIface.getProtocol());

				logger.debug("username: " + pubFileIface.getUsername());

				logger.debug("password: " + pubFileIface.getPassword());

				logger.debug("url: " + pubFileIface.getUrl());

				logger.debug("convention: " + pubFileIface.getConvention());

				getRepoAPI().insertPubFileInterface(repo.getId(), fileIface);

			}

		} catch (Exception e) {

			logger.error("error storing " + repo.getOfficialName() + "in openaire db", e);

			if (importResult == null)

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

			else

				this.addActionError(importResult);

			reportException(e);

			return "exception";

		}

		logger.debug("interfacesToRegister : " + interfacesToRegister.size());

		if (interfacesToRegister.size() > 0) {

			try {

	//			Map <String, String> compMap;

	//			compMap = getRepoAPI().getRepoCompatibility(repo.getOfficialName(), repo.getId());

				if (!this.getOpenAIREValidator().userOverridesRepoRegistration((String) session.get(Constants.loggedInField))) {

					logger.debug("User is not regRepoOverrrider");

	//FOR TESTING

//					this.adminEmails.clear();

//					this.adminEmails.add((String) session.get(Constants.loggedInField));

	//FOR TESTING

					for (RepositoryInterface iFace : interfacesToRegister) {

						if(iFace.getAccessSet() == null || iFace.getAccessSet().isEmpty()) {

							logger.debug("updating set to none");

							iFace.setAccessSet("none");

						}

						this.printInterface(iFace);

	//					logger.debug("current ComplianceEname: "+ iFace.getComplianceName());

	//					logger.debug("current ComplianceCode: "+ iFace.getCompliance());

	//					logger.debug("desired Compliance: "+ iFace.getDesiredCompatibilityLevel());

	//					if ((this.getDbMode().equalsIgnoreCase("direct") && !compMap.containsKey(iFace.getDesiredCompatibilityLevel())) 

	//					 || (this.getDbMode().equalsIgnoreCase("dms") && (!(iFace.getDesiredCompatibilityLevel().equalsIgnoreCase(getComplianceCode(iFace.getCompliance()))) && 

	//							 !(iFace.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire2.0_data") && getComplianceCode(iFace.getCompliance()).equalsIgnoreCase("openaire2.0"))))){

						if (this.getDbMode().equalsIgnoreCase("dms") && (!(iFace.getDesiredCompatibilityLevel().equalsIgnoreCase(iFace.getCompliance())) && 

										 !(iFace.getDesiredCompatibilityLevel().equalsIgnoreCase("openaire2.0_data") && iFace.getCompliance().equalsIgnoreCase("openaire2.0")))){

							logger.debug("initiating preregistration validations on repo :" + iFace.getBaseUrl() + "for set: " + iFace.getAccessSet() + " and compliance: " + iFace.getDesiredCompatibilityLevel());

							JobForRegistration job = new JobForRegistration();

							job.setActivation_id(UUID.randomUUID().toString());

							job.setAdmin_emails(this.adminEmails);

							job.setBaseurl(iFace.getBaseUrl());

							job.setDatasource_id(repo.getId());

							job.setDesired_compatiblity_level(iFace.getDesiredCompatibilityLevel());

							job.setInterface_id(iFace.getId());

							job.setInterface_id_old(null);

							job.setOfficial_name(repo.getOfficialName());

							job.setRepo_type(repoType);

							job.setUser((String) session.get(Constants.loggedInField));

							job.setValidation_set(iFace.getAccessSet());

							job.setPurpose("register");

							this.printInterface(iFace);

							this.getOpenAIREValidator().storeJobForRegistration(job);

							this.getOpenAIREValidator().preRegistrationValidations(job);

						} else {

							logger.debug("repo :" + iFace.getBaseUrl() + " for : " + iFace.getAccessSet() + " is already compliant on desiredcompliance: " + iFace.getCompliance());

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

							rec.add((String) session.get(Constants.loggedInField));

							String msgUpgrade = "";

							if (iFace.getCompliance() != null && !mode.equalsIgnoreCase("re3data") && !iFace.getCompliance().equalsIgnoreCase("openaire3.0"))

								msgUpgrade = "\n\n Please consider to upgrade to OpenAIRE Guidelines v3. Link: https://guidelines.openaire.eu/wiki/OpenAIRE_Guidelines:_For_Literature_repositories";

							this.getEmailer().sendMail(rec, "Request to Join OpenAIRE - Test Results [" + repo.getOfficialName() + "]", "Your " + repoType + " is already \"" + iFace.getDesiredCompatibilityLevel() + "\" compliant. As a result, there is no need to run registration test for url: " + iFace.getBaseUrl() + " and set: " + iFace.getAccessSet() + " ." + msgUpgrade, false, null);

						}

					}

					String validationStarted = "Compatibility test(s) for the " + repoType + " you wish to add have automatically started . You will be notified via email with further instructions when the test(s) has finished. For this " + repoType + " to be added in the OpenAIRE compliant list, the test must be successful.";

					this.addActionMessage(validationStarted);

	//				this.addActionMessage(this.getText("repoRegistration.validationStarted"));

					this.addActionMessage("Administrator email:" + this.adminEmails.get(0));

					this.addActionMessage((this.getText("general.unblock") + " " + this.getEmailer().getFrom()));

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

					recipients.addAll(this.adminEmails);

					this.getEmailer().sendMail(recipients, "Request to Join OpenAIRE - Confirmation [" + repo.getOfficialName() + "]", "A request has been sent to add '" + repo.getOfficialName() + "' " + repoType + " to the OpenAIRE compliant list. If you have any questions you can communicate with the user that made the request using this email: " + (String) session.get(Constants.loggedInField), false, null);

					recipients.clear();

					recipients.add((String) session.get(Constants.loggedInField));

					this.getEmailer().sendMail(recipients, "Request to Join OpenAIRE - Confirmation [" + repo.getOfficialName() + "]", "A request has been sent to add '" + repo.getOfficialName() + "' " + repoType + " to the OpenAIRE compliant list. The neccessary compatibility tests will begin shortly", true, null);

				} else {

					logger.debug("User is regRepoOverrider");

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

					recipients.add((String) session.get(Constants.loggedInField));

					this.getEmailer().sendMail(recipients, "Request to Join OpenAIRE [" + repo.getOfficialName() + "]", "A request has been sent to add '" + repo.getOfficialName() + "' to the OpenAIRE compliant list. Since you are logged-in as administrator, registration tests are bypassed.", false, null);

					this.addActionMessage((this.getText("repoRegistration.overriden.successful")));

					for (RepositoryInterface iFace : repo.getInterfaces()) {

						getRepoAPI().updateRepositoryInterfaceCompliance(repo.getOfficialName(), repo.getId(), iFace.getId(), iFace.getDesiredCompatibilityLevel(),iFace.getAccessSet(),iFace.getBaseUrl(), iFace.getExtraFields().get("oldId"));				}

				}

			} catch (Exception e) {

				logger.error("error registering repo " + repo.getOfficialName(), e);

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

				reportException(e);

				return "exception";

			}

		}

		return Action.SUCCESS;

	}

	private String getCountryCode(String countryName) {

		Vocabulary countries = vocabularyLoader.getVocabulary("dnet:countries", Locale.ENGLISH, Locale.ROOT);

		return countries.getEncoding(countryName);

	}

//	private String getComplianceCode(String complianceName) {

//		Vocabulary compatibilityLevels = vocabularyLoader.getVocabulary("dnet:compatibilityLevel", Locale.ENGLISH, Locale.ROOT);

//

//		return compatibilityLevels.getEncoding(complianceName);

//	}

	public void validate() {

		this.clearErrorsAndMessages();

		typologies = Constants.typologies;

		countries = vocabularyLoader.getVocabulary("dnet:countries", Locale.ENGLISH, Locale.ROOT).getEnglishNames();

		timezones = Constants.timezones;

		if (mode.equals("journal")){

			logger.debug("issn length: " + repo.getIssn().length());

			if (RepoExtAPI.FieldInEmpty(repo.getIssn()))

				this.addFieldError("issn", this.getText("compulsoryField"));

			if (repo.getIssn().length() != 8)

				this.addFieldError("issn", "Length has to be 8 characters");

			if (!RepoExtAPI.FieldInEmpty(repo.getEissn()) && repo.getEissn().length() != 8)

				this.addFieldError("eissn", "Length has to be 8 characters");

			if (!RepoExtAPI.FieldInEmpty(repo.getLissn()) && repo.getLissn().length() != 8)

				this.addFieldError("lissn", "Length has to be 8 characters");

		}

			if (!RepoExtAPI.FieldInEmpty(customTypology)) {

				repo.setTypology(customTypology);

			}

			if (RepoExtAPI.FieldInEmpty(repo.getTypology())) {

				this.addFieldError("typology", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getOfficialName())) {

				this.addFieldError("officialName", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getEnglishName())) {

				this.addFieldError("englishName", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getCountryName())) {

				this.addFieldError("countryName", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getWebsiteUrl())) {

				this.addFieldError("websiteUrl", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getOrganization())) {

				this.addFieldError("organization", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getContactEmail())) {

				this.addFieldError("contactEmail", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getLatitude().toString())) {

				this.addFieldError("latitude", this.getText("compulsoryField"));

			}

			if (RepoExtAPI.FieldInEmpty(repo.getLongitude().toString())) {

				this.addFieldError("longitude", this.getText("compulsoryField"));

			}

		this.adminEmails = new ArrayList<String>();

		for (RepositoryInterface iFace : this.interfaces) {

//			if(!iFace.isDeleteApi()) {

				logger.debug("checking baseurl: " + iFace.getBaseUrl());

				Identification identify;

				OaiPmhServer harvester = new OaiPmhServer(iFace.getBaseUrl());

				try {

					identify = harvester.identify();

				} catch (Exception e) {

					logger.error("error getting mails from url: " + iFace.getBaseUrl(), e);

					this.addFieldError("baseUrl", "BaseUrl: " + iFace.getBaseUrl() + " is invalid.");

//					this.addActionError(this.getText("invalidBaseUrl"));

					return;

				}

/*				try {

					SetsList setList = harvester.listSets();

					ResumptionToken token = setList.getResumptionToken();

					List<Set> sets = new ArrayList<Set>();

					sets.addAll(setList.asList());

					while (token != null) {

						setList = harvester.listSets(token);

						token = setList.getResumptionToken();

						sets.addAll(setList.asList());

					}

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

					for (Set set : sets) {

						ret.add(set.getSpec().trim());

					}

					if (!ret.contains(iFace.getAccessSet()))

						this.addFieldError("validationSet", "Set: " + iFace.getAccessSet() + " is not exposed by the repository. \n Please make sure that 'ListSets' verb is configured correctly on your server as well as that the exposed sets list includes this set.");

				} catch (Exception e) {

					logger.error("error getting sets from url: " + iFace.getBaseUrl(), e);

					continue;

				}

				*/

				this.adminEmails.addAll(RepoExtAPI.removeMailTo(identify.getAdminEmails()));

//			}

		}

		logger.debug("admin mails ok");

		if (this.adminEmails.size() == 0) {

			logger.debug("adminMail: " + repo.getContactEmail());

			this.adminEmails.add(repo.getContactEmail());

//			this.addActionError(this.getText("noAdminEmail"));

//			return;

		}

		logger.debug("admin mail ok");

//		try {

//			String aggName = null;

//			if((aggName = getRepoAPI().getNameOfAggregator(officialName)) != null) {

//				this.addActionError(this.getText("registration.noAggregated")+": "+aggName);

//				return;

//			}

//		} catch(Exception e) {

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

//			reportException(e);

//			logger.error("", e);

//			return;

//		}

	}

	public List<String> getAdminEmails() {

		return adminEmails;

	}

	public void setAdminEmails(List<String> adminEmails) {

		this.adminEmails = adminEmails;

	}

	public List<String> getTypologies() {

		return typologies;

	}

	public void setTypologies(List<String> typologies) {

		this.typologies = typologies;

	}

	public List<String> getCountries() {

		return countries;

	}

	public void setCountries(List<String> countries) {

		this.countries = countries;

	}

	public List<Timezone> getTimezones() {

		return timezones;

	}

	public void setTimezones(List<Timezone> timezones) {

		this.timezones = timezones;

	}

	public void setCustomTypology(String customTypology) {

		this.customTypology = customTypology;

	}

	public String getCustomTypology() {

		return customTypology;

	}

	@Override

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

		this.session = session;

	}

	public void setUsingOpenDoar(boolean usingOpenDoar) {

		this.usingOpenDoar = usingOpenDoar;

	}

	public boolean isUsingOpenDoar() {

		return usingOpenDoar;

	}

	public String getAggregatorName() {

		return aggregatorName;

	}

	public void setAggregatorName(String aggregatorName) {

		this.aggregatorName = aggregatorName;

	}

	public VocabularyLoader getVocabularyLoader() {

		return vocabularyLoader;

	}

	public void setVocabularyLoader(VocabularyLoader vocabularyLoader) {

		this.vocabularyLoader = vocabularyLoader;

	}

	public Repository getRepo() {

		return repo;

	}

	public void setRepo(Repository repo) {

		this.repo = repo;

	}

	public String getMode() {

		return mode;

	}

	public void setMode(String mode) {

		this.mode = mode;

	}

	public List<RepositoryInterface> getInterfaces() {

		return interfaces;

	}

	public void setInterfaces(List<RepositoryInterface> interfaces) {

		this.interfaces = interfaces;

	}

	public String getId() {

		return id;

	}

	public void setId(String id) {

		this.id = id;

	}

	public PubFileInterface getPubFileIface() {

		return pubFileIface;

	}

	public void setPubFileIface(PubFileInterface pubFileIface) {

		this.pubFileIface = pubFileIface;

	}

	private void printInterface(RepositoryInterface iFace) {

		logger.debug("baseUrl: " + iFace.getBaseUrl());

		logger.debug("format: " + iFace.getAccessFormat());

		logger.debug("typology: " + iFace.getTypology());

		logger.debug("set: " + iFace.getAccessSet());

		logger.debug("des_comp_level: " + iFace.getDesiredCompatibilityLevel());

		logger.debug("cur_comp_level: " + iFace.getCompliance());

		logger.debug("protocol: " + iFace.getAccessProtocol());

		logger.debug("api_id: " + iFace.getId());

		logger.debug("removable: " + iFace.isRemovable());

		logger.debug("deleteApi: " + iFace.isDeleteApi());

	}

}