Create generic task for REST activity about flowable-engine

[mgrouch]

I propose the following interface

public interface RestCallIntf
{
    String postJson(EndPoint endPoint, String urlSuffix, String content);
    String putJson(EndPoint endPoint, String urlSuffix, String content);
    String getJson(EndPoint endPoint, String urlSuffix, Map<String, String> params);
    String deleteJson(EndPoint endPoint, String urlSuffix, Map<String, String> params);
}

where

public class EndPoint implements Serializable
{
    private String id;
    private String url;
    private String user;
    private String password;
    private int connectTimeout;
    private int readTimeout;
...
}

EndPoints could be built via EL expression on a first step of workflow like this:

${
execution.setVariables(endPoints.builder
       .add("endPoint1", "http://somehost:8080/restService", null, null, 10000, 10000)
       .map())
}

and a call from a Rest service task made like this:

${
restCall.getJson(endPoint1, "?param1=value1", null))
}

And the spring beans defined like this:

package org.flowable.app.service.addon;

@Component("endPoints")`
public class EndPoints
{
    public EndPointsBuilder getBuilder()
   {
        return new EndPointsBuilder();
    }
}

package org.flowable.app.service.addon;

@Component("restCall")
public class RestCall implements RestCallIntf
{ 
}

[mgrouch]

And JsonTool for parsing

package org.flowable.app.service.addon;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

@Component("jsonTool")
public class JsonTool
{
    private static final ObjectMapper mapper = new ObjectMapper();

    static
    {
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

    public <T> T toObject(String json, Class<T> clazz)
    {
        try
        {
            return mapper.readValue(json, clazz);
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }
    }

    public <T> T[] toArray(String json, Class<T[]> clazz)
    {
        return toObject(json, clazz);
    }

    public <T> List<T> toList(String json, Class<T[]> clazz)
    {
        return Arrays.asList(toArray(json, clazz));
    }

    public <T> Map<String, T> toMap(String json, Class<T> clazz)
    {
        try
        {
            return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, String.class, clazz));
        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }
    }

    public String toJsonString(Object val)
    {
        try
        {
            return mapper.writeValueAsString(val);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }

    public Object toObj(String json)
    {
        return toObject(json, Object.class);
    }

    public Object[] toArr(String json)
    {
        return toArray(json, Object[].class);
    }
}

so call EL can be like this:

${
jsonTool.toObj(restCall.getJson(endPoint1, "?param1=value1", null))
}

[mgrouch]

Looks like if this one is implemented together with
#183 (#183)

(Especially with approach from #183 to call many functions in single EL expression)

it will be possible to use flowable with REST services "as-is".
Workflow can be directly created in flowable-modeler with EL language and mix of REST calls
(No Java coding at ALL to create an application ready to run).

No writing custom beans, no spring configurations would be necessary

Thanks

[paulhh]

Please feel free to implement and submit a pull request.

[tijsrademakers]

REST task has been added