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.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 se.kb.oai.pmh.ResumptionToken;

import se.kb.oai.pmh.Set;

import se.kb.oai.pmh.SetsList;

import com.opensymphony.xwork2.Action;

import com.unboundid.util.Base64;

public class RepoEditing extends BaseValidatorAction implements SessionAware {

	private static final long serialVersionUID = 4471755337821603525L;

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

	private VocabularyLoader vocabularyLoader = null;

	private Map<String, Object> session;

	private List<String> adminEmails;

	private Repository repo;

	private List<RepositoryInterface> interfaces, interfacesNew, interfacesOld, interfacesToRegister = null;

	private PubFileInterface pubFileIface;

	private String customTypology;

	private String mode;

	private String id;

	private Boolean deleteInterfaces;

	private Boolean updateInterfaces;

	private Boolean updatePubFilesInterface;

	private Boolean updateRepoInfo;

	private Boolean saveNewInterfaces;

	public String aggregatorName;

	private boolean usingOpenDoar;

	private List<String> typologies;

	private List<String> countries;

	private List<Timezone> timezones;

	public String execute() {

		this.clearErrorsAndMessages();

		String action = "";

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

		repo.setInterfaces(this.interfaces);

		if (updateRepoInfo != null) {

			action = "updateRepoInfo";

			logger.debug("inside repoInf");

		}

		if (deleteInterfaces != null) {

			action = "deleteInterfaces";

			logger.debug("inside delete");

		}

		if (updateInterfaces != null) {

			action = "updateInterfaces";

			logger.debug("inside updInte");

		}

		logger.debug("editing action: " + action);

		logger.debug("mode: " + mode);

		logger.debug("usingOpenDoar:" + usingOpenDoar);

		logger.debug("repoId " + id);

		String importResult = null;

		if (updateRepoInfo != null) {

			try {

				logger.debug("updating repo information");

				if (this.isModeOpenAIRE()) {

				 importResult = getRepoAPI().updateRepositoryInformation(repo);		

				}

				if (importResult != null)

					this.addActionMessage(importResult);

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

			}

		} else if (deleteInterfaces != null) {

			try {

				logger.debug("deleting selected interfaces");

				importResult = this.getRepoAPI().deleteRepositoryInterfaces(id, repo.getInterfaces());

				this.addActionMessage(importResult);

			} catch (Exception e) {

				logger.error("error deleting selected interfaces for repo: " + repo.getId() + "in openaire db", e);

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

				reportException(e);

				return "exception";

			}

		} else if (updatePubFilesInterface != null) {

			try {

				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().updatePubFileInterface(repo.getId(), fileIface);

				}

			}catch (Exception e) {

					logger.error("error deleting selected interfaces for repo: " + repo.getId() + "in openaire db", e);

					if (importResult == null)

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

					else

						this.addActionError(importResult);

					reportException(e);

					return "exception";

				}

		}

		else if (updateInterfaces != null) {

			try {

				logger.debug("updating selected interfaces");

//				logger.debug("updated interfaces size: " + repo.getInterfaces().size());

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

//					this.printInterface(iFace);

//				}

//

//				logger.debug("old interfaces size: " + interfacesOld.size());

//				for (RepositoryInterface iFace : interfacesOld) {

//					this.printInterface(iFace);

//				}

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

				if (interfacesNew.isEmpty()) {

					logger.debug("interfaces empty");

				} else {

					interfacesToRegister = this.getRepoAPI().updateRepositoryInterfaces(repo.getId(), interfacesNew, interfacesOld, mode);

				}

			} catch (Exception e) {

				logger.error("error updating interfaces for repo: " + repo.getId() + "in openaire db", e);

				if (importResult == null)

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

				else

					this.addActionError(importResult);

				reportException(e);

				return "exception";

			}

		} else if (saveNewInterfaces != null) {

				try {

					logger.debug("saving new interfaces");

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

					if (interfacesNew.isEmpty()) {

						logger.debug("interfaces empty");

					} else {

						interfacesToRegister = this.getRepoAPI().insertRepositoryInterfaces(repo.getId(), interfacesNew, mode);

					}

				} catch (Exception e) {

					logger.error("error saving new interfaces for repo: " + repo.getId() + "in openaire db", e);

					if (importResult == null)

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

					else

						this.addActionError(importResult);

					reportException(e);

					return "exception";

				}

		}

		try {

			if (interfacesToRegister != null) {

				logger.debug("Registering new interfaces.. Size: " + interfacesToRegister.size());

				for (RepositoryInterface iFace : interfacesToRegister)

				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

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

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

//					this.getOpenAIREValidator().storeJobForRegistration(iFace.getBaseUrl(), repo.getOfficialName(), activationId, (String) session.get(Constants.loggedInField), this.adminEmails, iFace.getAccessSet(), iFace.getDesiredCompatibilityLevel(), repo.getId(), iFace.getId());

//					this.getOpenAIREValidator().preRegistrationValidations(iFace.getBaseUrl(), repo.getOfficialName(), activationId, (String) session.get(Constants.loggedInField), this.adminEmails, iFace.getAccessSet(), iFace.getDesiredCompatibilityLevel(), repo.getId(), iFace.getId());

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

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

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

//					if (iFace.getCompliance() != null && !getComplianceCode(iFace.getCompliance()).equalsIgnoreCase("openaire3.0")) {

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

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

//					String msgUpgrade = "";

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

//					}

					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", "A request has been sent to add '" + repo.getOfficialName() + "' to the OpenAIRE compliant list of repositories/journals. 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", "A request has been sent to add '" + repo.getOfficialName() + "' to the OpenAIRE compliant list of repositories/journals. 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", "A request has been sent to add '" + repo.getOfficialName() + "' to the OpenAIRE compliant list of repositories/journals. Since you are logged-in as administrator, registration tests are bypassed.", false, null);

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

					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 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 (saveNewInterfaces != null) {

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

			for (RepositoryInterface iFace : interfacesNew) {

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

				}

		}

/*

		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;

	}

	public Boolean getDeleteInterfaces() {

		return deleteInterfaces;

	}

	public void setDeleteInterfaces(Boolean deleteInterfaces) {

		this.deleteInterfaces = deleteInterfaces;

	}

	public Boolean getUpdateInterfaces() {

		return updateInterfaces;

	}

	public void setUpdateInterfaces(Boolean updateInterfaces) {

		this.updateInterfaces = updateInterfaces;

	}

	public Boolean getUpdateRepoInfo() {

		return updateRepoInfo;

	}

	public void setUpdateRepoInfo(Boolean updateRepoInfo) {

		this.updateRepoInfo = updateRepoInfo;

	}

	public Boolean getUpdatePubFilesInterface() {

		return updatePubFilesInterface;

	}

	public void setUpdatePubFilesInterface(Boolean updatePubFilesInterface) {

		this.updatePubFilesInterface = updatePubFilesInterface;

	}

	public List<RepositoryInterface> getInterfacesOld() {

		return interfacesOld;

	}

	public void setInterfacesOld(List<RepositoryInterface> interfacesOld) {

		this.interfacesOld = interfacesOld;

	}

	public List<RepositoryInterface> getInterfacesNew() {

		return interfacesNew;

	}

	public void setInterfacesNew(List<RepositoryInterface> interfacesNew) {

		this.interfacesNew = interfacesNew;

	}

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

	}

	public Boolean getSaveNewInterfaces() {

		return saveNewInterfaces;

	}

	public void setSaveNewInterfaces(Boolean saveNewInterfaces) {

		this.saveNewInterfaces = saveNewInterfaces;

	}

}