D-Net

package eu.dnetlib.functionality.modular.ui.workflows.controllers;

import java.io.IOException;

import java.time.format.DateTimeFormatter;

import java.util.stream.StreamSupport;

import javax.servlet.http.HttpServletResponse;

import eu.dnetlib.functionality.modular.ui.repositories.util.RepoUIUtils;

import eu.dnetlib.functionality.modular.ui.workflows.util.ISLookupClient;

import eu.dnetlib.functionality.modular.ui.workflows.util.ISRegistryClient;

import eu.dnetlib.msro.logging.LogMessage;

import eu.dnetlib.rmi.datasource.DatasourceManagerServiceException;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.math.NumberUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.Node;

import org.dom4j.io.SAXReader;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.core.io.ClassPathResource;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

 * Web controller for the UI

 */

@Controller

	@Resource(name = "msroWorkflowLogger")

	private DnetLogger dnetLogger;

	private String compatibilityLevelsVocabulary;

	}

		if (dsNode != null) {

			final String ifaceId = dsNode.valueOf("@interface");

			final String dsProfile = this.isLookupClient.getProfile(dsId);

			final Document doc2 = reader.read(new StringReader(dsProfile));

			dsNode.addAttribute("name", doc2.valueOf("//OFFICIAL_NAME"));

			final Node ifcNode = doc2.selectSingleNode("//INTERFACE[@id = '" + ifaceId + "']");

			final Element extraFields = dsNode.addElement("extraFields");

			for (final Object o : ifcNode.selectNodes("./INTERFACE_EXTRA_FIELD")) {

				final Element f = extraFields.addElement("field");

				f.addAttribute("name", ((Node) o).valueOf("@name"));

				f.setText(((Node) o).getText());

	public @ResponseBody GraphDetails getWorkflowGraphHtml(@RequestParam(value = "wfId", required = true) final String id) throws Exception {

		final String profile = this.isLookupClient.getProfile(id);

		final Document doc = new SAXReader().read(new StringReader(profile));

	public @ResponseBody List<Map<String, String>> getFormProtocolParameters(@RequestParam(value = "ds", required = true) final String repoId,

			@RequestParam(value = "iface", required = true) final String ifaceId)

			throws Exception {

		final String profile = this.isLookupClient.getRepoProfile(repoId);

		final SAXReader reader = new SAXReader();

		final Document doc = reader.read(new StringReader(profile));

		final Node ifcNode = doc.selectSingleNode("//INTERFACE[@id = '" + ifaceId + "']");

		final String protocol = ifcNode.valueOf("./ACCESS_PROTOCOL");

		final List<Map<String, String>> list = new ArrayList<>();

		final Map<String, String> baseUrlParam = new HashMap<>();

		baseUrlParam.put("name", "baseUrl");

		baseUrlParam.put("type", ProtocolParameterType.TEXT.toString());

		baseUrlParam.put("value", ifcNode.valueOf("./BASE_URL"));

		baseUrlParam.put("regex", "^(http|https|ftp|ftps|sftp|file):\\/\\/");

		list.add(baseUrlParam);

		this.repoUIUtils.listParametersForProtocol(protocol).stream().map(pp -> {

			final Map<String, String> res = new HashMap<>();

			res.put("name", pp.getName());

			res.put("type", pp.getType().toString());

			res.put("value", ifcNode.valueOf("./ACCESS_PROTOCOL/@" + pp.getName()));

			if (StringUtils.isNotBlank(pp.getRegex())) {

				res.put("regex", pp.getRegex());

			}

			if (pp.isFunctionPopulated()) {

				res.put("functionPopulated", "true");

			}

			if (pp.isOptional()) {

				res.put("optional", "true");

			}

			return res;

		}).forEach(list::add);;

		return list;

	}

	public void getWorkflowHtml(final HttpServletResponse res,

			@RequestParam(value = "repoId", required = true) final String repoId,

			@RequestParam(value = "ifaceId", required = true) final String ifaceId) throws Exception {

		final String profile = this.isLookupClient.getRepoProfile(repoId);

		final SAXReader reader = new SAXReader();

		final Document doc = reader.read(new StringReader(profile));

		final Node ifcNode = doc.selectSingleNode("//INTERFACE[@id = '" + ifaceId + "']");

		final String profileId = doc.valueOf("//RESOURCE_IDENTIFIER/@value");

		for (final VocabularyEntry e : this.repoUIUtils.fetchVocabularyTerms(this.compatibilityLevelsVocabulary)) {

			final Element l = compLevels.addElement("level");

			l.setText(e.getName());

		}

			p.setText(((Node) o).getText());

		}

		final Element extraFields = extra.addElement("extraFields");

		for (final Object o : ifcNode.selectNodes("./INTERFACE_EXTRA_FIELD")) {

			final Element f = extraFields.addElement("field");

			f.addAttribute("name", ((Node) o).valueOf("@name"));

			f.setText(((Node) o).getText());

		}

			wf.addAttribute("id", item.getWfId());

			wf.addAttribute("name", item.getName());

			wf.addAttribute("description", item.getDesc());

				wf.addAttribute("destroy", "1");

			}

		params.put("baseUrl", ifcNode.valueOf("./BASE_URL"));

		params.put("prefix", doc.valueOf(".//FIELD[./key = 'NamespacePrefix']/value"));

		params.put("typology", ifcNode.valueOf("@typology"));

		params.put("compliance", ifcNode.valueOf("@compliance"));

		params.put("overrideCompliance", ifcNode.valueOf("./INTERFACE_EXTRA_FIELD[@name='overriding_compliance']"));

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/CONFIGURATION/INTERFACES").detach();

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/CONFIGURATION/EXTRA_FIELDS").detach();

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/QOS").detach();

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/STATUS").detach();

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/SECURITY_PARAMETERS").detach();

		doc.selectSingleNode("/RESOURCE_PROFILE/BODY/BLACKBOARD").detach();

		res.setContentType("text/html");

		return process != null ? new ProcessInfo(process) : new ProcessInfo(procId);

	}

	@RequestMapping("/ui/wf/wfTemplate.start")

	public @ResponseBody ProcessInfo startWorkflowTemplate(

			@RequestParam(value = "node", required = true) final String nodeName,

			@RequestParam(value = "parentWf", required = true) final String parentWf) throws Exception {

		final String profile = this.isLookupClient.getProfile(parentWf);

		final Document doc = (new SAXReader()).read(new StringReader(profile));

		final String family = doc.valueOf("//WORKFLOW_FAMILY");

		final int priority = NumberUtils.toInt(doc.valueOf("//WORKFLOW_PRIORITY"), WorkflowsConstants.DEFAULT_WF_PRIORITY);

		final String dsId = doc.valueOf("//DATASOURCE/@id");

		final String iface = doc.valueOf("//DATASOURCE/@interface");

		final Map<String, String> globalParams = new HashMap<String, String>();

		for (final Object o : doc.selectNodes("//CONFIGURATION/PARAMETERS/PARAM")) {

			final Element p = (Element) o;

			globalParams.put(p.valueOf("@name"), p.getTextTrim());

						this.graphLoader.calculateParamsForNode(node, globalParams))

		if (!params.containsKey("wfTemplateId") || !(params.get("wfTemplateId") instanceof String)

				|| StringUtils.isBlank((String) params.get("wfTemplateId"))) {

			log.error("wfTemplateId is invalid or missing in profile " + parentWf);

			throw new MSROException("wfTemplateId is invalid or missing in profile " + parentWf);

		}

		if (params.containsKey("wfTemplateParams") && !(params.get("wfTemplateParams") instanceof Map)) {

			log.error("wfTemplateParams is invalid in profile " + parentWf);

			throw new MSROException("wfTemplateParams is invalid in profile " + parentWf);

		}

		final String wfTtemplateId = (String) params.get("wfTemplateId");

		@SuppressWarnings("unchecked")

		final Map<String, String> wfTtemplateParams =

				params.containsKey("wfTemplateParams") ? (Map<String, String>) params.get("wfTemplateParams") : new HashMap<>();

		final String procId = this.workflowExecutor.startWorkflowTemplate(wfTtemplateId, nodeName, family, priority, dsId, iface, wfTtemplateParams, null);

		final WorkflowProcess process = this.graphProcessRegistry.findProcess(procId);

		return process != null ? new ProcessInfo(process) : new ProcessInfo(procId);

	public @ResponseBody WorkflowUpdateInfo getWorkflowUpdateInfo(@RequestParam(value = "wfId", required = true) final String wfId) throws Exception {

		final String xml = this.isLookupClient.getProfile(wfId);

		final Document doc = (new SAXReader()).read(new StringReader(xml));

		final WorkflowUpdateInfo info = new WorkflowUpdateInfo();

		info.setWfId(wfId);

		info.setMode(StartMode.valueOf(doc.valueOf("//CONFIGURATION/@start")));

		info.setPriority(NumberUtils.toInt(doc.valueOf("//WORKFLOW_PRIORITY"), WorkflowsConstants.DEFAULT_WF_PRIORITY));

		info.setScheduled("true".equalsIgnoreCase(doc.valueOf("//SCHEDULING/@enabled")));

		info.setCron(doc.valueOf("//SCHEDULING/CRON"));

		info.setInterval(NumberUtils.toInt(doc.valueOf("//SCHEDULING/MININTERVAL"), 120)); // Default: 120 minutes

		for (final Object o : doc.selectNodes("//NOTIFICATIONS/EMAIL")) {

			info.getNotifications().add(new WorkflowNotificationInfo(

					((Element) o).valueOf("@address"),

					((Element) o).valueOf("@messageProfileId"),

					NotificationCondition.valueOf(((Element) o).valueOf("@condition"))));

		}

		return info;

	}

		final boolean res = this.isRegistryClient.updateWorkflowProfile(info.getWfId(), xml, info);

		this.graphProcessRegistry.findProcess(id).kill();

		final LocalDateTime endDate = LocalDate.parse(end, formatter).atTime(23, 59);

		final LocalDateTime now = LocalDateTime.now();

				.map(this::toProcessInfo)

				.collect(Collectors.toMap(e -> e.getProcId(), e -> e, (e1, e2) -> e1));

		}

			StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false)

					.map(this::toProcessInfo)

					.forEach(e -> map.put(e.getProcId(), e));

				map.put(proc.getProfileId(), new ProcessInfo(proc));

		}

			@Override

			public int compare(final ProcessInfo p1, final ProcessInfo p2) {

					return -1;

				} else if (p2.getDate() == 0) {

					return 1;

				} else {

					return Long.compare(p2.getDate(), p1.getDate());

				}

			throws IOException {

		final Iterator<Map<String, String>> iterator = this.dnetLogger.find(WorkflowsConstants.LOG_WF_FAMILY, family);

		return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false)

				.map(this::toProcessInfo)

				.collect(Collectors.toList());

		final WorkflowProcess process = this.graphProcessRegistry.findProcess(procId);

		final Map<String, String> logs = this.dnetLogger.findOne("system:processId", procId);

	}

		return this.isLookupClient.obtainSubWorkflows(wfId);

	@RequestMapping(value = "/ui/wf/repohi_wfs.find")

	public @ResponseBody List<RepoHIWorkflow> listRepoHIWorkflows(@RequestParam(value = "compliance", required = true) final String compliance,

			@RequestParam(value = "type", required = true) final String type) throws ISLookUpException {

		return this.isLookupClient.listRepoHiWorkflows(compliance, type);

	}

	@RequestMapping("/ui/wf/repohi.start")

			@RequestParam(value = "wf", required = true) final String wfId) throws Exception {

			@Override

			public void onSuccess() {

				try {

					WorkflowsController.this.serviceLocator.getService(DatasourceManagerService.class).updateActivationStatus(repoId, ifaceId, true);

				} catch (final DatasourceManagerServiceException e) {

			}

			@Override

			public void onFail() {}

		});

		return Arrays.asList(procId);

	@RequestMapping("/ui/wf/repobye.start")

		final String profile = this.isLookupClient.getProfile(wf);

		final Document doc = (new SAXReader()).read(new StringReader(profile));

		final String dsId = doc.valueOf("//DATASOURCE/@id");

		final String iface = doc.valueOf("//DATASOURCE/@interface");

		final Map<String, String> globalParams = new HashMap<String, String>();

		for (final Object o : doc.selectNodes("//CONFIGURATION/PARAMETERS/PARAM")) {

			final Element p = (Element) o;

			globalParams.put(p.valueOf("@name"), p.getTextTrim());

		}

		final Node node = doc.selectSingleNode("//DESTROY_WORKFLOW_TEMPLATE");

		if (node == null) {

			log.error("DESTROY WF is invalid or missing in profile " + wf);

			throw new MSROException("DESTROY WF is invalid or missing in profile " + wf);

		}

		final String wfTtemplateId = node.valueOf("@id");

		final Map<String, String> params = GraphNode.newNode("REPO_BYE", "REPO_BYE",

				this.graphLoader.calculateParamsForNode(node, globalParams))

				.filter(e -> e.getValue() instanceof String)

				.collect(Collectors.toMap(e -> e.getKey(), e -> (String) e.getValue(), (e1, e2) -> e1));

		final String procId =

				this.workflowExecutor.startWorkflowTemplate(wfTtemplateId, "REPO_BYE", "REPO_BYE", WorkflowsConstants.DEFAULT_WF_PRIORITY, dsId, iface,

						params, new ProcessCallback() {

							@Override

							public void onSuccess() {

								try {

									WorkflowsController.this.isRegistryClient.deleteProfile(wf);

								} catch (final ISRegistryException e) {

									log.error("Error deleting workflow: " + wf);

								}

							}

							@Override

							public void onFail() {}

						});

		return Arrays.asList(procId);

		final ProcessInfo info = new ProcessInfo();