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.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.annotation.PostConstruct;

import javax.annotation.Resource;

import javax.imageio.ImageIO;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;

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

import org.dom4j.Node;

import org.joda.time.DateTime;

import org.joda.time.format.DateTimeFormat;

import org.joda.time.format.DateTimeFormatter;

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

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

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 eu.dnetlib.common.logging.DnetLogger;

import eu.dnetlib.common.logging.LogMessage;

import eu.dnetlib.common.services.locators.DnetServiceLocator;

import eu.dnetlib.enabling.datastructures.MetaWorkflow;

import eu.dnetlib.enabling.datastructures.Workflow;

import eu.dnetlib.enabling.datastructures.WorkflowInstance;

import eu.dnetlib.enabling.datastructures.WorkflowInstance.ConfigurationStatus;

import eu.dnetlib.enabling.datastructures.WorkflowInstance.StartMode;

import eu.dnetlib.enabling.is.client.InformationServiceClient;

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

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

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

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

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

import eu.dnetlib.miscutils.DateUtils;

import eu.dnetlib.msro.dispatcher.ProcessInfo;

import eu.dnetlib.msro.dispatcher.WorkflowDispatcher;

import eu.dnetlib.msro.dispatcher.WorkflowRegistry;

import eu.dnetlib.msro.worker.WorkflowConstants;

import eu.dnetlib.rmi.object.manager.ProcessImageDesc;

import eu.dnetlib.rmi.object.manager.ProcessNodeDesc;

import eu.dnetlib.rmi.objects.is.BlackboardActionStatus;

import eu.dnetlib.rmi.soap.ManagerWorkerService;

import eu.dnetlib.rmi.soap.exceptions.InformationServiceException;

/**

 * Web controller for the UI

 * 

 * @author Michele Artini

 */

@Controller

public class WorkflowsController extends AbstractAjaxController {

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

		@Override

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

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

			String repo = "";

			if (input.containsKey(WorkflowConstants.DATAPROVIDER_NAME)) {

				repo += input.get(WorkflowConstants.DATAPROVIDER_NAME);

			}

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

			final String metaWfId = input.get(WorkflowConstants.SYSTEM_METAWF_ID);

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

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

			final long startDate = NumberUtils.toLong(input.get(WorkflowConstants.SYSTEM_START_DATE), 0);

			final BlackboardActionStatus status = Boolean.valueOf(input.get(WorkflowConstants.SYSTEM_COMPLETED_SUCCESSFULLY)) ? BlackboardActionStatus.DONE

					: BlackboardActionStatus.FAILED;

			final int priority = NumberUtils.toInt(input.get(WorkflowConstants.SYSTEM_WF_PRIORITY), 0);

			final ProcessInfo info = new ProcessInfo(metaWfId, name, repo, family, procId, startDate, priority);

			info.setLastActivityDate(date);

			info.setStatus(status);

			return info;

		}

	}

	@Autowired

	private WorkflowDispatcher dispatcher;

	@Autowired

	private WorkflowRegistry wfRegistry;

	@Autowired

	private InformationServiceClient isClient;

	@Resource

	private ProcessGraphGenerator processGraphGenerator;

	@Resource

	private DnetServiceLocator serviceLocator;

	@Resource(name = "msroWorkflowLogger")

	private DnetLogger dnetLogger;

	@Value("${workflows.categories.viewers.json}")

	private String paramViewersForCategoryJson;

	private Map<String, List<WorkflowParamViewer>> paramViewers = Maps.newHashMap();

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

	@PostConstruct

	private void init() {

		log.info("Initialing categoryUis map using JSON: " + paramViewersForCategoryJson);

		this.paramViewers = new Gson().fromJson(paramViewersForCategoryJson, new TypeToken<Map<String, List<WorkflowParamViewer>>>() {}.getType());

	}

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

	public @ResponseBody

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

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

		if (sectionName != null) {

			return isClient.listResourceWithProperty("section", sectionName, MetaWorkflow.class);

		} else if (dsId != null) {

			return isClient.listResourceWithProperty("datasource", dsId, MetaWorkflow.class);

		} else {

			return Lists.newArrayList();

		}

	}

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

	public @ResponseBody

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

		return isClient.getResourceByCode(id, MetaWorkflow.class);

	}

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

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

		final Workflow wf = isClient.getResourceByCode(code, Workflow.class);

		final BufferedImage image = processGraphGenerator.getWfDescImage(code, wf);

		sendImage(response, image);

	}

	@RequestMapping("/ui/workflow.map")

	public @ResponseBody

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

		final Workflow wf = isClient.getResourceByCode(code, Workflow.class);

		return processGraphGenerator.getWfDescImageMap(code, wf);

	}

	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.start")

	public @ResponseBody

	boolean startWorkflow(@RequestParam(value = "metaWf", required = true) final String metaWfId,

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

		dispatcher.dispatchWorkFlow(metaWfId, wfName);

		return true;

	}

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

	public @ResponseBody

	boolean startMetaWorkflow(@RequestParam(value = "metaWf", required = true) final String metaWfId) throws Exception {

		dispatcher.dispatchMetaWorkFlow(metaWfId);

		return true;

	}

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

	public @ResponseBody

	NodeInfo workflowNode_info(@RequestParam(value = "wf", required = true) final String wfCode,

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

		final Document doc = isClient.getResourceByCode(wfCode, Workflow.class).asDocument();

		final Node n = doc.selectSingleNode("//NODE[@name='" + nodeName + "']");

		final String name = nodeName;

		final String description = n.valueOf("./DESCRIPTION");

		final boolean start = "true".equalsIgnoreCase(n.valueOf("@isStart"));

		final boolean join = "true".equalsIgnoreCase(n.valueOf("@isJoin"));

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

		for (Object o : n.selectNodes("./PARAMETERS/PARAM")) {

			final Node p = (Node) o;

			params.put(p.valueOf("@name"), p.getText());

		}

		return new NodeInfo(name, description, start, join, params);

	}

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

	public @ResponseBody

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

		final MetaWorkflow metaWf = new Gson().fromJson(json, MetaWorkflow.class);

		log.info("Updating metaWorkflow " + metaWf.getName());

		isClient.updateResource(metaWf);

		return true;

	}

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

	public @ResponseBody

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

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

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

			final String newCode = "metawf-" + UUID.randomUUID();

			final MetaWorkflow metaWf = isClient.getResourceByCode(code, MetaWorkflow.class);

			metaWf.setCode(newCode);

			metaWf.setName(newName);

			isClient.registerResource(metaWf);

			return newCode;

		} else {

			throw new IllegalArgumentException("Name is empty");

		}

	}

	@RequestMapping(value = "/ui/wf_proc_node.json", produces = "application/json")

	public @ResponseBody

	ProcessNodeDesc getProcessWorkflowNode(@RequestParam(value = "proc", required = true) final String procId,

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

		final ProcessInfo proc = wfRegistry.findProcess(procId);

		final ManagerWorkerService mws = serviceLocator.getService(ManagerWorkerService.class, proc.getWorkerId());

		return mws.getProcessNodeDesc(procId, nodeId);

	}

	/*

	 * private NodeToken findNodeToken(final String pid, final long nid) { final GraphProcess process =

	 * graphProcessRegistry.findProcess(pid); if (process != null) { for (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 (Node node : process.getGraph().getNodes()) { if (node.getId() == nid) { return node.getName(); } } }

	 * return "-"; }

	 */

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

	public @ResponseBody

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

		/*

		 * GraphProcess proc = graphProcessRegistry.findProcess(id); proc.setState(ProcessState.Canceled); return true;

		 */

		// TODO

		return false;

	}

	@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 (String pid : wfRegistry.listProcIds()) {

				res.put(pid, wfRegistry.findProcess(pid));

			}

		}

		return res.values();

	}

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

	public @ResponseBody

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

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

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

		for (String wfId : wfFilter) {

			final Iterator<ProcessInfo> iter = Iterators.transform(dnetLogger.find(WorkflowConstants.SYSTEM_METAWF_ID, wfId),

					new JournalEntryFunction());

			while (iter.hasNext()) {

				ProcessInfo e = iter.next();

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

			}

		}

		for (String pid : wfRegistry.listProcIds()) {

			final ProcessInfo proc = wfRegistry.findProcess(pid);

			if (wfFilter.contains(proc.getMetaWfId())) {

				res.put(pid, proc);

			}

		}

		return res.values();

	}

	@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(WorkflowConstants.SYSTEM_WF_PROFILE_FAMILY, family),

				new JournalEntryFunction());

		return Lists.newArrayList(iter);

	}

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

	public @ResponseBody

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

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

		res.put("procId", procId);

		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) {

				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 ProcessInfo process = wfRegistry.findProcess(procId);

		if (process != null) {

			res.put("name", process.getWfName());

			res.put("worker", process.getWorkerId());

			res.put("startDate", process.getStartDate());

			if (process.getStatus() == BlackboardActionStatus.DONE || process.getStatus() == BlackboardActionStatus.FAILED) {

				res.put("endDate", process.getLastActivityDate());

			} else {

				res.put("endDate", 0);

			}

			if (process.getStatus() != BlackboardActionStatus.ASSIGNED) {

				final ProcessImageDesc desc = processGraphGenerator.getProcessImageDesc(procId);

				if (desc != null) {

					res.put("WF_IMAGE_BASE64", desc.getBase64());

					res.put("WF_IMAGE_MAP", desc.getImageMap());

					res.put("WF_IMAGE_FORMAT", desc.getFormat());

				}

			}

		}

		return res;

	}

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

	public @ResponseBody

	String enableAtomicWf(@RequestParam(value = "metaWf", required = true) final String metaWfId,

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

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

		final MetaWorkflow metaWf = isClient.getResourceByCode(metaWfId, MetaWorkflow.class);

		final WorkflowInstance wfi = metaWf.findWorkflowInstanceByName(wfName);

		if (wfi != null) {

			wfi.setStartMode(StartMode.valueOf(value.toUpperCase()));

			isClient.updateResource(metaWf);

		}

		return value;

	}

	@SuppressWarnings("unchecked")

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

	public @ResponseBody

	List<WorkflowParam>

			listWorkflowUserParams(@RequestParam(value = "metaWf", required = true) final String metaWfId,

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

		final MetaWorkflow metaWf = isClient.getResourceByCode(metaWfId, MetaWorkflow.class);

		final WorkflowInstance wfi = metaWf.findWorkflowInstanceByName(wfName);

		final Map<String, String> actualParams = wfi.getParams();

		final Document doc = isClient.getResourceByCode(wfi.getWfCode(), Workflow.class).asDocument();

		return Lists.transform(doc.selectNodes("//CONFIGURATION/PARAM"), new Function<Object, WorkflowParam>() {

			@Override

			public WorkflowParam apply(final Object o) {

				final Node n = (Node) o;

				final String key = n.valueOf("@name");

				final boolean required = "true".equalsIgnoreCase(n.valueOf("@required"));

				final String type = n.valueOf("@type");

				final String function = n.valueOf("@function");

				final String value = actualParams.containsKey(key) ? actualParams.get(key) : n.getText();

				final boolean userParam = "user".equals(n.valueOf("@managedBy"));

				final String category = n.valueOf("@category");

				final List<WorkflowParamViewer> uis =

						!StringUtils.isEmpty(category) && paramViewers.containsKey(category) ?

								paramViewers.get(category) : new ArrayList<WorkflowParamViewer>();

				return new WorkflowParam(key, value, required, userParam, type, function, uis);

			}

		});

	}

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

	public @ResponseBody

	boolean saveWorkflowUserParams(@RequestParam(value = "metaWf", required = true) final String metaWfId,

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

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

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

		final MetaWorkflow metaWf = isClient.getResourceByCode(metaWfId, MetaWorkflow.class);

		final WorkflowInstance wfi = metaWf.findWorkflowInstanceByName(wfName);

		wfi.setConfigurationStatus(ConfigurationStatus.CONFIGURED);

		wfi.setParams(new HashMap<String, String>());

		for (WorkflowParam p : params) {

			wfi.getParams().put(p.getName(), p.getValue());

			if (p.isRequired() && StringUtils.isBlank(p.getValue())) {

				wfi.setConfigurationStatus(ConfigurationStatus.NOT_CONFIGURED);

			}

		}

		isClient.updateResource(metaWf);

		return true;

	}

}