D-Net

{"type_source": "SVN", "goal": "package -U -T 4C source:jar", "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet45/modules/dnet-modular-workflows-ui/trunk/", "deploy_repository": "dnet45-snapshots", "version": "4", "mail": "sandro.labruzzo@isti.cnr.it,michele.artini@isti.cnr.it, claudio.atzori@isti.cnr.it, alessia.bardi@isti.cnr.it", "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet45-snapshots", "name": "dnet-modular-workflows-ui"}

package eu.dnetlib;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestSuite;

/**

 * Unit test for simple App.

 */

public class AppTest 

    extends TestCase

{

    /**

     * Create the test case

     *

     * @param testName name of the test case

     */

    public AppTest( String testName )

    {

        super( testName );

    }

    /**

     * @return the suite of tests being tested

     */

    public static Test suite()

    {

        return new TestSuite( AppTest.class );

    }

    /**

     * Rigourous Test :-)

     */

    public void testApp()

    {

        assertTrue( true );

    }

}

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

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import com.google.common.collect.Lists;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.msro.workflows.util.ValidNodeValuesFetcher;

public class ListProfilesValues extends ValidNodeValuesFetcher {

	@Resource

	private UniqueServiceLocator serviceLocator;

	@Override

	protected List<DnetParamValue> obtainValues(final Map<String, String> params) throws Exception {

		verifyParams(params, "type", "xpath");

		final List<DnetParamValue> values = Lists.newArrayList();

		final String query = "for $x in /*[.//RESOURCE_TYPE/@value='" + params.get("type") + "']" + "return concat($x//RESOURCE_IDENTIFIER/@value, ' @@@ ', $x"

				+ params.get("xpath") + ")";

		final List<String> result = serviceLocator.getService(ISLookUpService.class).quickSearchProfile(query);

		for (String s : result) {

			String[] arr = s.split("@@@");

			values.add(new DnetParamValue(arr[0].trim(), arr[1].trim()));

		}

		return values;

	}

}

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

import java.io.File;

import java.util.List;

import java.util.Map;

import org.springframework.core.io.Resource;

import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import org.springframework.core.io.support.ResourcePatternResolver;

import com.google.common.collect.Lists;

import eu.dnetlib.msro.workflows.util.ValidNodeValuesFetcher;

public class ListFilesValues extends ValidNodeValuesFetcher {

	private final ResourcePatternResolver pathResolver = new PathMatchingResourcePatternResolver();

	@Override

	protected List<DnetParamValue> obtainValues(final Map<String, String> params) throws Exception {

		verifyParams(params, "path", "ext");

		final String pathTmp = params.get("path");

		final String path = pathTmp.startsWith("/") ? pathTmp : "/" + pathTmp;

		final List<DnetParamValue> values = Lists.newArrayList();

		for (Resource r : pathResolver.getResources("classpath*:" + path + "/*." + params.get("ext"))) {

			values.add(new DnetParamValue(path + File.separator + r.getFilename(), r.getFilename()));

		}

		return values;

	}

}

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

import java.util.Collections;

import java.util.List;

import java.util.Set;

import javax.annotation.Resource;

import com.google.common.collect.Lists;

import com.google.common.collect.Sets;

import eu.dnetlib.functionality.modular.ui.AbstractMenu;

import eu.dnetlib.functionality.modular.ui.MenuEntry;

import eu.dnetlib.functionality.modular.ui.users.AccessLimited;

import eu.dnetlib.functionality.modular.ui.users.PermissionLevel;

import eu.dnetlib.functionality.modular.ui.workflows.objects.sections.WorkflowSectionGrouper;

public class InfrastructureManagementGroup extends AbstractMenu implements AccessLimited {

	private int order;

	@Resource

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Override

	public List<MenuEntry> getEntries() {

		final List<String> list = Lists.newArrayList(workflowSectionGrouper.getAllSectionNames());

		Collections.sort(list);

		List<MenuEntry> res = Lists.newArrayList();

		for(int i=0; i<list.size(); i++) {

			res.add(new WorkflowSectionEntryPoint(list.get(i), i));

		}

		return res;

	}

	@Override

	public int getOrder() {

		return order;

	}

	public void setOrder(int order) {

		this.order = order;

	}

	@Override

	public Set<PermissionLevel> getPermissionLevels() {

		return Sets.newHashSet(PermissionLevel.WF_ADMIN, PermissionLevel.IS_ADMIN);

	}

}

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

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

import eu.dnetlib.functionality.modular.ui.MenuEntry;

public class WorkflowSectionEntryPoint extends MenuEntry {

	public WorkflowSectionEntryPoint(String s, int order) {

		setTitle(s);

		setMenu(s);

		setDescription(s);

		setOrder(order);

	}

	@Override

	public String getRelativeUrl() {

		try {

			return "/ui/workflows.do?section=" + URLEncoder.encode(getMenu(), "UTF-8");

		} catch (UnsupportedEncodingException e) {

			return "javascript:void(0)";

		}

	}

}

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

import java.io.IOException;

import java.io.StringReader;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.stereotype.Controller;

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

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

import com.google.common.collect.Maps;

import com.google.gson.Gson;

import eu.dnetlib.msro.workflows.util.ValidNodeValuesFetcher;

import eu.dnetlib.msro.workflows.util.ValidNodeValuesFetcher.DnetParamValue;

@Controller

public class DnetParamValuesController {

	@Resource

	private List<ValidNodeValuesFetcher> validNodesFetchers;

	private static final Log log = LogFactory.getLog(DnetParamValuesController.class);

	@RequestMapping("/ui/**/wf_obtainValidValues.list")

	public void obtainValidValues(final HttpServletRequest request,

			final HttpServletResponse response,

			@RequestParam(value = "bean", required = true) final String bean) throws IOException {

		final ValidNodeValuesFetcher fetcher = findValidNodeValuesFetcher(bean);

		if (fetcher == null) {

			log.error("ValidNodeValuesFetcher not found: " + bean);

			sendResponse(response, new ArrayList<ValidNodeValuesFetcher.DnetParamValue>());

		} else {

			final Map<String, String> params = findParams(request);

			sendResponse(response, fetcher.evaluate(params));

		}

	}

	private ValidNodeValuesFetcher findValidNodeValuesFetcher(final String bean) {

		for (ValidNodeValuesFetcher fetcher : validNodesFetchers) {

			if (fetcher.getName().equals(bean)) { return fetcher; }

		}

		return null;

	}

	private Map<String, String> findParams(final HttpServletRequest request) {

		final Map<String, String> params = Maps.newHashMap();

		final Enumeration<?> e = request.getParameterNames();

		while (e.hasMoreElements()) {

			final String name = (String) e.nextElement();

			params.put(name, request.getParameter(name));

		}

		return params;

	}

	private void sendResponse(final HttpServletResponse response, final List<DnetParamValue> values) throws IOException {

		Collections.sort(values);

		response.setContentType("application/json;charset=UTF-8");

		IOUtils.copy(new StringReader(new Gson().toJson(values)), response.getOutputStream());

	}

}

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

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.io.OutputStream;

import java.io.StringReader;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.Resource;

import javax.imageio.ImageIO;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.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.io.SAXReader;

import org.joda.time.DateTime;

import org.joda.time.format.DateTimeFormat;

import org.joda.time.format.DateTimeFormatter;

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;

import com.google.common.base.Function;

import com.google.common.collect.Iterators;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

import com.googlecode.sarasvati.GraphProcess;

import com.googlecode.sarasvati.Node;

import com.googlecode.sarasvati.NodeToken;

import com.googlecode.sarasvati.ProcessState;

import eu.dnetlib.common.logging.DnetLogger;

import eu.dnetlib.common.logging.LogMessage;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpException;

import eu.dnetlib.functionality.modular.ui.AbstractAjaxController;

import eu.dnetlib.functionality.modular.ui.workflows.objects.AdvancedMetaWorkflowDescriptor;

import eu.dnetlib.functionality.modular.ui.workflows.objects.AtomicWorkflowDescriptor;

import eu.dnetlib.functionality.modular.ui.workflows.objects.MetaWorkflowDescriptor;

import eu.dnetlib.functionality.modular.ui.workflows.objects.NodeInfo;

import eu.dnetlib.functionality.modular.ui.workflows.objects.NodeTokenInfo;

import eu.dnetlib.functionality.modular.ui.workflows.objects.NodeWithUserParams;

import eu.dnetlib.functionality.modular.ui.workflows.objects.ProcessListEntry;

import eu.dnetlib.functionality.modular.ui.workflows.objects.sections.WorkflowSectionGrouper;

import eu.dnetlib.functionality.modular.ui.workflows.sarasvati.viewer.ProcessGraphGenerator;

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

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

import eu.dnetlib.miscutils.datetime.DateUtils;

import eu.dnetlib.msro.workflows.sarasvati.loader.ProfileToSarasvatiConverter;

import eu.dnetlib.msro.workflows.sarasvati.loader.WorkflowExecutor;

import eu.dnetlib.msro.workflows.sarasvati.registry.GraphProcessRegistry;

import eu.dnetlib.msro.workflows.util.ProcessUtils;

import eu.dnetlib.msro.workflows.util.WorkflowsConstants;

import eu.dnetlib.msro.workflows.util.WorkflowsConstants.WorkflowStatus;

/**

 * Web controller for the UI

 *

 * @author Michele Artini

 */

@Controller

public class WorkflowsController extends AbstractAjaxController {

	private final class JournalEntryFunction implements Function<Map<String, String>, ProcessListEntry> {

		@Override

		public ProcessListEntry apply(final Map<String, String> input) {

			final String name = input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_NAME);

			final String repo = input.containsKey(WorkflowsConstants.DATAPROVIDER_NAME) ? input.get(WorkflowsConstants.DATAPROVIDER_NAME) : "";

			final String repoId = input.containsKey(WorkflowsConstants.DATAPROVIDER_ORIGINALID) ? input.get(WorkflowsConstants.DATAPROVIDER_ORIGINALID) : "";

			final String apiId = input.containsKey(WorkflowsConstants.DATAPROVIDER_INTERFACE) ? input.get(WorkflowsConstants.DATAPROVIDER_INTERFACE) : "";

			final String procId = input.get(WorkflowsConstants.SYSTEM_WF_PROCESS_ID);

			final String wfId = input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_ID);

			final String family = input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_FAMILY);

			final long date = NumberUtils.toLong(input.get(LogMessage.LOG_DATE_FIELD), 0);

			final String status = Boolean.valueOf(input.get(WorkflowsConstants.SYSTEM_COMPLETED_SUCCESSFULLY)) ? "SUCCESS" : "FAILURE";

			return new ProcessListEntry(procId, wfId, name, family, status, date, repo, repoId, apiId);

		}

	}

	@Resource

	private ISLookupClient isLookupClient;

	@Resource

	private ISRegistryClient isRegistryClient;

	@Resource

	private GraphProcessRegistry graphProcessRegistry;

	@Resource

	private ProcessGraphGenerator processGraphGenerator;

	@Resource

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Resource

	private WorkflowExecutor workflowExecutor;

	@Resource

	private ProfileToSarasvatiConverter profileToSarasvatiConverter;

	@Resource(name = "msroWorkflowLogger")

	private DnetLogger dnetLogger;

	private static final Log log = LogFactory.getLog(WorkflowsController.class);

	@RequestMapping("/ui/list_metaworkflows.json")

	public @ResponseBody List<MetaWorkflowDescriptor> listMetaWorflowsForSection(@RequestParam(value = "section", required = false) final String sectionName,

			@RequestParam(value = "dsId", required = false) final String dsId)

			throws ISLookUpException, IOException {

		if (sectionName != null) {

			return workflowSectionGrouper.listMetaWorflowsForSection(sectionName);

		} else if (dsId != null) {

			return workflowSectionGrouper.listMetaWorflowsForDatasource(dsId);

		} else {

			return Lists.newArrayList();

		}

	}

	@RequestMapping("/ui/wf_metaworkflow.json")

	public @ResponseBody AdvancedMetaWorkflowDescriptor getMetaWorkflow(@RequestParam(value = "id", required = true) final String id) throws Exception {

		return isLookupClient.getMetaWorkflow(id);

	}

	@RequestMapping("/ui/wf_atomic_workflow.json")

	public @ResponseBody AtomicWorkflowDescriptor getAtomicWorkflow(@RequestParam(value = "id", required = true) final String id) throws Exception {

		final AtomicWorkflowDescriptor wf = isLookupClient.getAtomicWorkflow(id);

		final String xml = profileToSarasvatiConverter.getSarasvatiWorkflow(id).getWorkflowXml();

		wf.setMapContent(processGraphGenerator.getWfDescImageMap(id, xml));

		return wf;

	}

	@RequestMapping("/ui/wf_atomic_workflow.img")

	public void showAtomicWorkflow(final HttpServletResponse response, @RequestParam(value = "id", required = true) final String id) throws Exception {

		final String xml = profileToSarasvatiConverter.getSarasvatiWorkflow(id).getWorkflowXml();

		final Set<String> notConfiguredNodes = isLookupClient.getNotConfiguredNodes(id);

		final BufferedImage image = processGraphGenerator.getWfDescImage(id, xml, notConfiguredNodes);

		sendImage(response, image);

	}

	private void sendImage(final HttpServletResponse response, final BufferedImage image) throws IOException {

		response.setContentType("image/png");

		final OutputStream out = response.getOutputStream();

		ImageIO.write(image, "png", out);

		out.flush();

		out.close();

	}

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

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

		return workflowExecutor.startProcess(id);

	}

	@RequestMapping("/ui/metawf.start")

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

		workflowExecutor.startMetaWorkflow(id, true);

		return id;

	}

	@RequestMapping("/ui/wf_workflow_node.json")

	public @ResponseBody NodeInfo workflowNode_info(@RequestParam(value = "wf", required = true) final String wfId,

			@RequestParam(value = "node", required = true) final String nodeName) throws ISLookUpException, IOException {

		return isLookupClient.getNodeInfo(wfId, nodeName);

	}

	@RequestMapping("/ui/wf_metaworkflow.edit")

	public @ResponseBody boolean scheduleMetaWorkflow(@RequestParam(value = "json", required = true) final String json) throws Exception {

		final AdvancedMetaWorkflowDescriptor info = new Gson().fromJson(json, AdvancedMetaWorkflowDescriptor.class);

		log.info("Updating workflow " + info.getName());

		final String xml = isLookupClient.getProfile(info.getWfId());

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

		return res;

	}

	@RequestMapping("/ui/clone_metaworkflow.do")

	public @ResponseBody String cloneMetaWf(@RequestParam(value = "id", required = true) final String id,

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

		if (name.trim().length() > 0) {

			final String xml = isLookupClient.getProfile(id);

			final SAXReader reader = new SAXReader();

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

			doc.selectSingleNode("//METAWORKFLOW_NAME").setText(name);

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

				final Element n = (Element) o;

				final String atomWfXml = isLookupClient.getProfile(n.valueOf("@id"));

				final String newAtomWfId = isRegistryClient.registerProfile(atomWfXml);

				n.addAttribute("id", newAtomWfId);

			}

			return isRegistryClient.registerProfile(doc.asXML());

		} else {

			throw new IllegalArgumentException("Name is empty");

		}

	}

	@RequestMapping("/ui/wf_proc_node.json")

	public @ResponseBody NodeTokenInfo getProcessWorkflowNode(@RequestParam(value = "id", required = true) final String pid,

			@RequestParam(value = "node", required = true) final long nid) throws Exception {

		final NodeToken token = findNodeToken(pid, nid);

		final NodeTokenInfo info = token == null ? new NodeTokenInfo(findNodeName(pid, nid)) : new NodeTokenInfo(token);

		return info;

	}

	private NodeToken findNodeToken(final String pid, final long nid) {

		final GraphProcess process = graphProcessRegistry.findProcess(pid);

		if (process != null) {

			for (final NodeToken token : process.getNodeTokens()) {

				if (token.getNode().getId() == nid) { return token; }

			}

		}

		return null;

	}

	private String findNodeName(final String pid, final long nid) {

		final GraphProcess process = graphProcessRegistry.findProcess(pid);

		if (process != null) {

			for (final Node node : process.getGraph().getNodes()) {

				if (node.getId() == nid) { return node.getName(); }

			}

		}

		return "-";

	}

	@RequestMapping("/ui/wf_proc.img")

	public void showProcessWorkflow(final HttpServletResponse response, @RequestParam(value = "id", required = true) final String id) throws Exception {

		final BufferedImage image = processGraphGenerator.getProcessImage(id);

		sendImage(response, image);

	}

	@RequestMapping("/ui/wf_proc.kill")

	public @ResponseBody boolean killProcessWorkflow(@RequestParam(value = "id", required = true) final String id) throws Exception {

		final GraphProcess proc = graphProcessRegistry.findProcess(id);

		proc.setState(ProcessState.Canceled);

		return true;

	}

	@RequestMapping("/ui/wf_journal.range")

	public @ResponseBody Collection<ProcessListEntry> rangeWfJournal(@RequestParam(value = "start", required = true) final String start,

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

		final Map<String, ProcessListEntry> res = Maps.newHashMap();

		final DateTimeFormatter formatter = DateTimeFormat.forPattern("yyyy-MM-dd");

		final DateTime startDate = formatter.parseDateTime(start);

		final DateTime endDate = formatter.parseDateTime(end).plusHours(23).plusMinutes(59).plusSeconds(59);

		final Iterator<ProcessListEntry> iter = Iterators.transform(dnetLogger.range(startDate.toDate(), endDate.toDate()), new JournalEntryFunction());

		while (iter.hasNext()) {

			final ProcessListEntry e = iter.next();

			res.put(e.getProcId(), e);

		}

		final long now = DateUtils.now();

		if (startDate.isBefore(now) && endDate.isAfter(now)) {

			for (final String pid : graphProcessRegistry.listIdentifiers()) {

				final GraphProcess proc = graphProcessRegistry.findProcess(pid);

				res.put(pid, new ProcessListEntry(pid, proc));

			}

		}

		return res.values();

	}

	@RequestMapping("/ui/wf_journal.find")

	public @ResponseBody Collection<ProcessListEntry> findWfJournal(@RequestParam(value = "wfs", required = true) final String wfs) {

		final Map<String, ProcessListEntry> res = Maps.newHashMap();

		final Set<String> wfFilter = new Gson().fromJson(wfs, new TypeToken<Set<String>>() {}.getType());

		for (final String wfId : wfFilter) {

			final Iterator<ProcessListEntry> iter =

					Iterators.transform(dnetLogger.find(WorkflowsConstants.SYSTEM_WF_PROFILE_ID, wfId), new JournalEntryFunction());

			while (iter.hasNext()) {

				final ProcessListEntry e = iter.next();

				res.put(e.getProcId(), e);

			}

		}

		for (final String pid : graphProcessRegistry.listIdentifiers()) {

			final GraphProcess proc = graphProcessRegistry.findProcess(pid);

			if (wfFilter.contains(ProcessUtils.calculateWfId(proc))) {

				res.put(pid, new ProcessListEntry(pid, proc));

			}

		}

		return res.values();

	}

	@RequestMapping("/ui/wf_journal_byFamily.find")

	public @ResponseBody Collection<ProcessListEntry> findWfJournalByFamily(@RequestParam(value = "family", required = true) final String family)

			throws IOException {

		final Iterator<ProcessListEntry> iter =

				Iterators.transform(dnetLogger.find(WorkflowsConstants.SYSTEM_WF_PROFILE_FAMILY, family), new JournalEntryFunction());

		return Lists.newArrayList(iter);

	}

	@RequestMapping("/ui/wf_journal.get")

	public @ResponseBody Map<String, Object> getWfJournalLog(@RequestParam(value = "id", required = true) final String id) throws Exception {

		final Map<String, Object> res = Maps.newHashMap();

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

		if (logs != null && !logs.isEmpty()) {

			final List<String> keys = Lists.newArrayList(logs.keySet());

			Collections.sort(keys);

			final List<Map<String, String>> journalEntry = Lists.newArrayList();

			for (final String k : keys) {

				final Map<String, String> m = Maps.newHashMap();

				m.put("name", k);

				m.put("value", logs.get(k));

				journalEntry.add(m);

			}

			res.put("journal", journalEntry);

		}

		final GraphProcess process = graphProcessRegistry.findProcess(id);

		if (process != null) {

			final String mapContent = process.getState() == ProcessState.Created ? "" : processGraphGenerator.getProcessImageMap(id);

			String status = "";

			if (!process.isComplete()) {

				status = process.getState().toString().toUpperCase();

			} else if ("true".equals(process.getEnv().getAttribute(WorkflowsConstants.SYSTEM_COMPLETED_SUCCESSFULLY))) {

				status = "SUCCESS";

			} else {

				status = "FAILURE";

			}

			final String img =

					process.getState() == ProcessState.Created ? "../resources/img/notStarted.gif" : "wf_proc.img?id=" + id + "&t=" + DateUtils.now();

			final String name = process.getGraph().getName();

			final long startDate = NumberUtils.toLong(process.getEnv().getAttribute(WorkflowsConstants.SYSTEM_START_DATE), 0);

			final long endDate = NumberUtils.toLong(process.getEnv().getAttribute(WorkflowsConstants.SYSTEM_END_DATE), 0);

			final AtomicWorkflowDescriptor wf = new AtomicWorkflowDescriptor(id, name, status, mapContent, img, true, "auto", "RUNNING", startDate, endDate);

			res.put("graph", wf);

		}

		return res;

	}

	@RequestMapping("/ui/wf_atomic_workflow.enable")

	public @ResponseBody String enableAtomicWf(@RequestParam(value = "id", required = true) final String id,

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

		isRegistryClient.configureWorkflowStart(id, value);

		return value;

	}

	@RequestMapping("/ui/workflow_user_params.json")

	public @ResponseBody List<NodeWithUserParams> listWorkflowUserParams(@RequestParam(value = "wf", required = true) final String wfId) throws Exception {

		return isLookupClient.listWorkflowUserParams(wfId);

	}

	@RequestMapping(value = "/ui/save_user_params.do")

	public @ResponseBody boolean saveWorkflowUserParams(@RequestParam(value = "wf", required = true) final String wfId,

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

		final String xml = isLookupClient.getProfile(wfId);

		final List<NodeWithUserParams> params = new Gson().fromJson(jsonParams, new TypeToken<List<NodeWithUserParams>>() {}.getType());

		final boolean res = isRegistryClient.updateSarasvatiWorkflow(wfId, xml, params);

		for (final String metaWfId : isLookupClient.listMetaWorflowsForWfId(wfId)) {

			if (isLookupClient.isExecutable(metaWfId)) {

				isRegistryClient.updateMetaWorkflowStatus(metaWfId, WorkflowStatus.EXECUTABLE);

			} else {

				isRegistryClient.updateMetaWorkflowStatus(metaWfId, WorkflowStatus.WAIT_USER_SETTINGS);

			}

		}

		return res;

	}

}

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

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

public class WfTimelineEntryPointController extends ModuleEntryPoint {

	@Override

	protected void initialize(ModelMap map, HttpServletRequest request,

			HttpServletResponse response) throws Exception {

	}

}

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

import java.io.StringWriter;

import java.net.URLEncoder;

import java.util.List;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.ui.ModelMap;

import com.google.gson.Gson;

import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;

import eu.dnetlib.enabling.locators.UniqueServiceLocator;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

import eu.dnetlib.functionality.modular.ui.workflows.objects.sections.WorkflowSectionGrouper;

public class WfEntryPointController extends ModuleEntryPoint {

	@Resource

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Resource

	private UniqueServiceLocator serviceLocator;

	private static final Log log = LogFactory.getLog(WfEntryPointController.class);

	private final Gson gson = new Gson();

	@Override

	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) throws Exception {

		if (request.getParameterMap().containsKey("wfId")) {

			initialize_direct_wf(map, request);

		} else {

			initialize_normal(map, request);

		}

	}

	private void initialize_direct_wf(final ModelMap map, final HttpServletRequest request) {

		final String wfId = request.getParameter("wfId");

		final StringWriter sw = new StringWriter();

		sw.append("for $x in collection('/db/DRIVER/MetaWorkflowDSResources/MetaWorkflowDSResourceType') ");

		sw.append("where $x//WORKFLOW/@id='");

		sw.append(wfId);

		sw.append("' return concat(");

		sw.append("$x//METAWORKFLOW_SECTION, ");

		sw.append("' |=@=| ', ");

		sw.append("$x//RESOURCE_IDENTIFIER/@value, ");

		sw.append("' |=@=| ', ");

		sw.append("$x//DATAPROVIDER/@id, ");

		sw.append("' |=@=| ', ");

		sw.append("$x//DATAPROVIDER/@interface)");

		try {

			final List<String> list = serviceLocator.getService(ISLookUpService.class).quickSearchProfile(sw.toString());

			if (list.size() > 0) {

				final String[] arr = list.get(0).split("\\|=@=\\|");

				final String section = arr[0].trim();

				final String metaWf = arr[1].trim();

				final String repoId = arr[2].trim();

				final String repoApi = arr[3].trim();

				if (!StringUtils.isEmpty(repoId)

						&& !StringUtils.isEmpty(repoApi)

						&& !StringUtils.isEmpty(metaWf)

						&& !StringUtils.isEmpty(wfId)) {

					map.addAttribute("redirect",

							"repoApis.do#/api/" +

									URLEncoder.encode(repoId, "UTF-8") + "/" +

									URLEncoder.encode(repoApi, "UTF-8") + "/" +

									URLEncoder.encode(metaWf, "UTF-8") + "/" +

									URLEncoder.encode(wfId, "UTF-8"));

				} else {

					map.addAttribute("initialWf", gson.toJson(wfId));

					map.addAttribute("initialMetaWf", gson.toJson(metaWf));

					map.addAttribute("section", gson.toJson(section));

				}

			}

		} catch (Exception e) {

			log.error("Error obtaining details of wf " + wfId);

		}

	}

	private void initialize_normal(final ModelMap map, final HttpServletRequest request) {

		if (request.getParameterMap().containsKey("section")) {

			map.addAttribute("section", gson.toJson(request.getParameter("section")));

		}

		if (request.getParameterMap().containsKey("metaWf")) {

			map.addAttribute("initialMetaWf", gson.toJson(request.getParameter("metaWf")));

		}

	}

}

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

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.ui.ModelMap;

import eu.dnetlib.functionality.modular.ui.ModuleEntryPoint;

public class WfHistoryEntryPointController extends ModuleEntryPoint {

	@Override

	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) throws Exception {

		if (request.getParameterMap().containsKey("procId")) {

			map.addAttribute("procId", request.getParameter("procId"));

		}

		if (request.getParameterMap().containsKey("family")) {

			map.addAttribute("family", request.getParameter("family"));

		}

	}

}

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

import eu.dnetlib.msro.workflows.util.WorkflowsConstants.WorkflowStatus;

public class MetaWorkflowDescriptor extends AbstractWorkflowDescriptor {

	private WorkflowStatus statusEnum;

	private String familyName;

	public MetaWorkflowDescriptor(final String id, final String name, final WorkflowStatus statusEnum, final String familyName) {

		super(id, name, "");

		this.statusEnum = statusEnum;

		this.familyName = familyName;

	}

	public String getStatus() {

		return statusEnum.displayName;

	}

	public WorkflowStatus getStatusEnum() {

		return statusEnum;

	}

	public void setStatusEnum(final WorkflowStatus statusEnum) {

		this.statusEnum = statusEnum;

	}

	public String getFamilyName() {

		return familyName;

	}

	public void setFamilyName(final String familyName) {

		this.familyName = familyName;

	}

}

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

public class FilterCollection extends HashMap<String, List<FilterElem>> {

	/**

	 * 

	 */

	private static final long serialVersionUID = 4856177328627952130L;

	public FilterCollection() {

		super();

	}

	public void addElement(String collection, FilterElem elem) {

		if (!this.containsKey(collection)) {

			this.put(collection, new ArrayList<FilterElem>());

		}

		this.get(collection).add(elem);

	}

	public void addElement(String collection, String name, String icon, String value) {

		addElement(collection, new FilterElem(name, icon, value));

	}

}

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

import java.util.List;

import eu.dnetlib.msro.workflows.util.WorkflowParam;

public class NodeInfo {

	private String name;

	private String description;

	private List<WorkflowParam> params;

	public NodeInfo(String name, String description, List<WorkflowParam> params) {

		this.name = name;

		this.description = description;

		this.params = params;

	}

	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 List<WorkflowParam> getParams() {

		return params;

	}

	public void setParams(List<WorkflowParam> params) {

		this.params = params;

	}

}

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

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.List;

import java.util.Map;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.googlecode.sarasvati.NodeToken;

public class NodeTokenInfo {

	public class EnvParam {

		private String name;

		private String value;

		public EnvParam(final String name, final String value) {

			this.name = name;

			this.value = value;

		}

		public String getName() {

			return name;

		}

		public String getValue() {

			return value;

		}

	}

	private String name;

	private long start;

	private long end;

	private List<EnvParam> params;

	public NodeTokenInfo(final String name) {

		super();

		this.name = name;

		this.start = 0;

		this.end = 0;

		this.params = Lists.newArrayList();

	}

	public NodeTokenInfo(final NodeToken token) {

		super();

		final Date start = token.getCreateDate();

		final Date end = token.getCompleteDate();

		this.name = token.getNode().getName();

		this.start = start == null ? 0 : start.getTime();

		this.end = end == null ? 0 : end.getTime();

		final Map<String, EnvParam> map = Maps.newHashMap();

		for (String name : token.getFullEnv().getAttributeNames()) {

			map.put(name, new EnvParam(name, token.getFullEnv().getAttribute(name)));

		}

		for (String name : token.getEnv().getAttributeNames()) {

			map.put(name, new EnvParam(name, token.getEnv().getAttribute(name)));

		}

		this.params = Lists.newArrayList(map.values());

		Collections.sort(this.params, new Comparator<EnvParam>() {

			@Override

			public int compare(final EnvParam o1, final EnvParam o2) {

				if (o1 == null) {

					return -1;

				} else if (o2 == null) {

					return 1;

				} else {

					return o1.getName().compareTo(o2.getName());

				}

			}

		});

	}

	public String getName() {

		return name;

	}

	public long getStart() {

		return start;

	}

	public long getEnd() {

		return end;

	}

	public List<EnvParam> getParams() {

		return params;

	}

}

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

import java.util.List;

import eu.dnetlib.msro.workflows.util.WorkflowParam;

public class NodeWithUserParams {

	private String node;

	private String desc;

	private List<WorkflowParam> params;

	public NodeWithUserParams() {}

	public NodeWithUserParams(final String node, final String desc,	final List<WorkflowParam> params) {

		this.node = node;

		this.desc = desc;

		this.params = params;

	}

	public String getNode() {

		return node;

	}

	public void setNode(final String node) {

		this.node = node;

	}

	public String getDesc() {

		return desc;

	}

	public void setDesc(final String desc) {

		this.desc = desc;

	}

	public List<WorkflowParam> getParams() {

		return params;

	}

	public void setParams(final List<WorkflowParam> params) {

		this.params = params;

	}

}

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

import java.util.Set;

import com.google.common.collect.Sets;

import eu.dnetlib.msro.workflows.util.WorkflowsConstants.WorkflowStatus;

public class AdvancedMetaWorkflowDescriptor extends MetaWorkflowDescriptor {

	private String email;

	private boolean scheduled;

	private String cronExpression;

	private int minInterval;

	private Set<String> innerWfs = Sets.newHashSet();

	private String html;

	public AdvancedMetaWorkflowDescriptor(final String id, final String name, final String email,

			final boolean scheduled, final String cronExpression, final int minInterval, final WorkflowStatus statusEnum, final String family, final Set<String> innerWfs, final String html) {

		super(id, name, statusEnum, family);

		this.email = email;

		this.scheduled = scheduled;

		this.cronExpression = cronExpression;

		this.minInterval = minInterval;

		this.innerWfs = innerWfs;

		this.setHtml(html);

	}

	public boolean isScheduled() {

		return scheduled;

	}

	public void setScheduled(final boolean scheduled) {

		this.scheduled = scheduled;

	}

	public String getCronExpression() {

		return cronExpression;

	}

	public void setCronExpression(final String cronExpression) {

		this.cronExpression = cronExpression;

	}

	public int getMinInterval() {

		return minInterval;

	}

	public void setMinInterval(final int minInterval) {

		this.minInterval = minInterval;

	}

	public String getEmail() {

		return email;

	}

	public void setEmail(final String email) {

		this.email = email;

	}

	public Set<String> getInnerWfs() {

		return innerWfs;

	}

	public void setInnerWfs(Set<String> innerWfs) {

		this.innerWfs = innerWfs;

	}

	public String getHtml() {

		return html;

	}

	public void setHtml(String html) {

		this.html = html;

	}

}

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

public class AtomicWorkflowDescriptor extends AbstractWorkflowDescriptor implements WfGraphProvider {

	private String mapContent;

	private String status;

	private String imageUrl;

	private boolean ready;

	private String start;

	private String lastExecutionDate;

	private long startDate;

	private long endDate;

	public AtomicWorkflowDescriptor(final String id, final String name, final String status, final String mapContent,

			final String imageUrl, final boolean ready, final String start, final String lastExecutionDate, long startDate, long endDate) {

		super(id, name, "");

		this.status = status;

		this.mapContent = mapContent;

		this.imageUrl = imageUrl;

		this.ready = ready;

		this.start = start;

		this.lastExecutionDate = lastExecutionDate;

		this.startDate = startDate;

		this.endDate = endDate;

	}

	public long getStartDate() {

		return startDate;

	}

	public void setStartDate(long startDate) {

		this.startDate = startDate;

	}

	public long getEndDate() {

		return endDate;

	}

	public void setEndDate(long endDate) {

		this.endDate = endDate;

	}

	public void setMapContent(final String mapContent) {

		this.mapContent = mapContent;

	}

	public void setImageUrl(final String imageUrl) {

		this.imageUrl = imageUrl;

	}

	@Override

	public String getMapContent() {

		return mapContent;

	}

	@Override

	public String getImageUrl() {

		return imageUrl;

	}

	public boolean isReady() {

		return ready;

	}

	public void setReady(final boolean ready) {

		this.ready = ready;

	}

	public String getLastExecutionDate() {

		return lastExecutionDate;

	}

	public void setLastExecutionDate(final String lastExecutionDate) {

		this.lastExecutionDate = lastExecutionDate;

	}

	public String getStatus() {

		return status;

	}

	public void setStatus(final String status) {

		this.status = status;

	}

	public String getStart() {

		return start;

	}

	public void setStart(final String start) {

		this.start = start;

	}

}

package eu.dnetlib.functionality.modular.ui.workflows.objects.sections;

import java.util.List;

import java.util.Set;

import javax.annotation.Resource;

import com.google.common.collect.Sets;

import eu.dnetlib.functionality.modular.ui.workflows.objects.MetaWorkflowDescriptor;

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

import eu.dnetlib.miscutils.datetime.DateUtils;

public class WorkflowSectionGrouper {

	private Set<String> cache = Sets.newHashSet();

	private long cacheDate = 0;

	private static final long CACHE_DURATION = 600000; // 10 minutes

	@Resource

	private ISLookupClient isLookupClient;

	public List<MetaWorkflowDescriptor> listMetaWorflowsForDatasource(String dsId) {

		return isLookupClient.listMetaWorflowsForDatasource(dsId);

	}

	public List<MetaWorkflowDescriptor> listMetaWorflowsForSection(String name) {

		return isLookupClient.listMetaWorflowsForSection(name);

	}

	public String getDatasourceName(String dsId) {

		return isLookupClient.getDatasourceName(dsId);

	}

	public Set<String> getAllSectionNames() {

		synchronized (cache) {

			if (cache.isEmpty() || DateUtils.now() - cacheDate > CACHE_DURATION) {

				cache.clear();

				cache.addAll(isLookupClient.listSimpleWorflowSections());

				cacheDate = DateUtils.now();

			}

		}

		final Set<String> res = Sets.newHashSet(cache);

		res.remove("dataproviders");

		return res;

	}

}

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

public class FilterElem {

	private String name;

	private String icon;

	private String value;

	public FilterElem(String name, String icon, String value) {

		super();

		this.name = name;

		this.icon = icon;

		this.value = value;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getIcon() {

		return icon;

	}

	public void setIcon(String icon) {

		this.icon = icon;

	}

	public String getValue() {

		return value;

	}

	public void setValue(String value) {

		this.value = value;

	}

}

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

public interface WfGraphProvider {

	public String getMapContent();

	public String getImageUrl();

}

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

import java.util.Date;

import com.googlecode.sarasvati.GraphProcess;

import eu.dnetlib.msro.workflows.util.ProcessUtils;

public class ProcessListEntry {

	private String procId;

	private String wfId;

	private String name;

	private String family;

	private String status;

	private long date;

	private String repo;

	private String repoId;

	private String apiId;

	public ProcessListEntry() {}

	public ProcessListEntry(final String procId, final String wfId, final String name, final String family, final String status, final long date,

			final String repo, final String repoId, final String apiId) {

		this.procId = procId;

		this.wfId = wfId;

		this.name = name;

		this.family = family;

		this.status = status;

		this.date = date;

		this.repo = repo;

		this.repoId = repoId;

		this.apiId = apiId;

	}

	public ProcessListEntry(final String procId, final String wfId, final String name, final String family, final String status, final Date date,

			final String repo, final String repoId, final String apiId) {

		this(procId, wfId, name, family, status, dateToLong(date), repo, repoId, apiId);

	}

	public ProcessListEntry(final String procId, final GraphProcess process) {

		this(procId,

				ProcessUtils.calculateWfId(process),

				ProcessUtils.calculateName(process),

				ProcessUtils.calculateFamily(process),

				ProcessUtils.calculateStatus(process),

				ProcessUtils.calculateLastActivityDate(process),

				ProcessUtils.calculateRepo(process),

				ProcessUtils.calculateRepoId(process),

				ProcessUtils.calculateApiId(process));

	}

	public String getProcId() {

		return procId;

	}

	public void setProcId(final String procId) {