D-Net

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.*;

import javax.annotation.Resource;

import javax.imageio.ImageIO;

import javax.servlet.http.HttpServletResponse;

import com.google.common.base.Function;

import com.google.common.base.Splitter;

import com.google.common.collect.Iterators;

import com.google.common.collect.Lists;

import com.google.common.collect.Maps;

import com.google.common.collect.Sets;

import com.google.gson.Gson;

import com.google.gson.reflect.TypeToken;

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.EnvParam;

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

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

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

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

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.miscutils.functional.xml.ApplyXslt;

import eu.dnetlib.msro.workflows.procs.ProcessRegistry;

import eu.dnetlib.msro.workflows.procs.WorkflowExecutor;

import eu.dnetlib.msro.workflows.procs.WorkflowProcess;

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

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

import org.apache.commons.io.IOUtils;

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

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.joda.time.DateTime;

import org.joda.time.format.DateTimeFormat;

import org.joda.time.format.DateTimeFormatter;

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

 *

 * @author Michele Artini

 */

@Controller

public class WorkflowsController extends AbstractAjaxController {

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

	@Resource

	private ISLookupClient isLookupClient;

	@Resource

	private ISRegistryClient isRegistryClient;

	@Resource

	private ProcessRegistry graphProcessRegistry;

	@Resource

	private WorkflowSectionGrouper workflowSectionGrouper;

	@Resource

	private WorkflowExecutor workflowExecutor;

	@Resource(name = "msroWorkflowLogger")

	private DnetLogger dnetLogger;

	@RequestMapping("/ui/wf/list_workflows.json")

	public

	@ResponseBody

	List<WorkflowPair> listWorflowsForSection(@RequestParam(value = "section", required = false) final String sectionName,

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

			throws ISLookUpException, IOException {

		if (sectionName != null) {

			return workflowSectionGrouper.listWorflowsForSection(sectionName);

		} else if (dsId != null) {

			return workflowSectionGrouper.listWorflowsForDatasource(dsId);

		} else {

			return Lists.newArrayList();

		}

	}

	@RequestMapping("/ui/wf/workflow.html")

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

		final String profile = isLookupClient.getProfile(id);

		final ApplyXslt xslt = new ApplyXslt(new ClassPathResource("/eu/dnetlib/functionality/modular/workflows/xslt/wf_profile2html.xslt"));

		res.setContentType("text/html");

		IOUtils.copy(new StringReader(xslt.evaluate(profile)), res.getOutputStream());

	}

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

		response.setContentType("image/png");

		OutputStream out = response.getOutputStream();

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

		out.flush();

		out.close();

	}

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

	public

	@ResponseBody

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

		final String procId = workflowExecutor.startWorkflow(id, null, null);

		final WorkflowProcess process = graphProcessRegistry.findProcess(id);

		if (process != null) {

			return new ProcessInfo(process);

		} else {

			return new ProcessInfo(procId);

		}

	}

	@RequestMapping("/ui/wf/update_workflow.do")

	public

	@ResponseBody

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

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

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

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

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

		return res;

	}

	@RequestMapping("/ui/wf/proc.kill")

	public

	@ResponseBody

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

		graphProcessRegistry.findProcess(id).kill();

		return true;

	}

	@RequestMapping("/ui/wf/journal.range")

	public

	@ResponseBody

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

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

		final Map<String, ProcessInfo> 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<ProcessInfo> iter = Iterators.transform(dnetLogger.range(startDate.toDate(), endDate.toDate()), new JournalEntryFunction());

		while (iter.hasNext()) {

			ProcessInfo e = iter.next();

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

		}

		long now = DateUtils.now();

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

			for (WorkflowProcess proc : graphProcessRegistry.listProcesses()) {

				res.put(proc.getId(), new ProcessInfo(proc));

			}

		}

		return res.values();

	}

	@RequestMapping("/ui/wf/journal.find")

	public

	@ResponseBody

	List<ProcessInfo> findWfJournal(@RequestParam(value = "wfs", required = true) final String wfs) {

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

		final Set<String> wfFilter = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().trimResults().split(wfs));

		for (String wfId : wfFilter) {

			final Iterator<ProcessInfo> iter =

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

			while (iter.hasNext()) {

				ProcessInfo e = iter.next();

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

			}

		}

		for (WorkflowProcess proc : graphProcessRegistry.listProcesses()) {

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

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

			}

		}

		final List<ProcessInfo> res = Lists.newArrayList(map.values());

		Collections.sort(res, new Comparator<ProcessInfo>() {

			@Override

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

				if (p1.getDate() == 0) {

					return -1;

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

					return 1;

				} else {

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

				}

			}

		});

		return res;

	}

	@RequestMapping("/ui/wf/journal_byFamily.find")

	public

	@ResponseBody

	Collection<ProcessInfo> findWfJournalByFamily(@RequestParam(value = "family", required = true) final String family) throws IOException {

		final Iterator<ProcessInfo> iter =

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

		return Lists.newArrayList(iter);

	}

	@RequestMapping("/ui/wf/journal.get")

	public

	@ResponseBody

	ProcessInfo getWfJournalLog(@RequestParam(value = "id", required = true) final String procId) throws Exception {

		final WorkflowProcess process = graphProcessRegistry.findProcess(procId);

		final ProcessInfo info = (process != null) ? new ProcessInfo(process) : new ProcessInfo();

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

		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 (String k : keys) {

				info.getCurrentEnv().add(new EnvParam(k, logs.get(k)));

			}

		}

		return info;

	}

	@RequestMapping(value = "/ui/wf/saveParams.do")

	public

	@ResponseBody

	boolean saveWorkflowParams(@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 Map<String, String> params = new Gson().fromJson(jsonParams, new TypeToken<Map<String, String>>() {

		}.getType());

		return isRegistryClient.updateWorkflowProfile(wfId, xml, params);

	}

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

		@Override

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

			final ProcessInfo info = new ProcessInfo();

			info.setProcId(input.get(WorkflowsConstants.SYSTEM_WF_PROCESS_ID));

			info.setWfId(input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_ID));

			info.setName(input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_NAME));

			info.setFamily(input.get(WorkflowsConstants.SYSTEM_WF_PROFILE_FAMILY));

			info.setDatasource(input.containsKey(WorkflowsConstants.DATASOURCE_NAME) ? input.get(WorkflowsConstants.DATASOURCE_NAME) : "");

			info.setStatus(Boolean.valueOf(input.get(WorkflowsConstants.SYSTEM_COMPLETED_SUCCESSFULLY)) ? "SUCCESS" : "FAILURE");

			info.setDate(NumberUtils.toLong(input.get(LogMessage.LOG_DATE_FIELD), 0));

			info.setStartDate(NumberUtils.toLong(input.get(WorkflowsConstants.SYSTEM_START_DATE), 0));

			info.setEndDate(NumberUtils.toLong(input.get(WorkflowsConstants.SYSTEM_END_DATE), 0));

			return info;

		}

	}

}